1//===- ASTReader.cpp - AST File Reader ------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the ASTReader class, which reads AST files.
10//
11//===----------------------------------------------------------------------===//
12
13#include "clang/Serialization/ASTReader.h"
14#include "ASTCommon.h"
15#include "ASTReaderInternals.h"
16#include "clang/AST/ASTConsumer.h"
17#include "clang/AST/ASTContext.h"
18#include "clang/AST/ASTMutationListener.h"
19#include "clang/AST/ASTUnresolvedSet.h"
20#include "clang/AST/Decl.h"
21#include "clang/AST/DeclBase.h"
22#include "clang/AST/DeclCXX.h"
23#include "clang/AST/DeclFriend.h"
24#include "clang/AST/DeclGroup.h"
25#include "clang/AST/DeclObjC.h"
26#include "clang/AST/DeclTemplate.h"
27#include "clang/AST/DeclarationName.h"
28#include "clang/AST/Expr.h"
29#include "clang/AST/ExprCXX.h"
30#include "clang/AST/ExternalASTSource.h"
31#include "clang/AST/NestedNameSpecifier.h"
32#include "clang/AST/ODRHash.h"
33#include "clang/AST/RawCommentList.h"
34#include "clang/AST/TemplateBase.h"
35#include "clang/AST/TemplateName.h"
36#include "clang/AST/Type.h"
37#include "clang/AST/TypeLoc.h"
38#include "clang/AST/TypeLocVisitor.h"
39#include "clang/AST/UnresolvedSet.h"
40#include "clang/Basic/CommentOptions.h"
41#include "clang/Basic/Diagnostic.h"
42#include "clang/Basic/DiagnosticOptions.h"
43#include "clang/Basic/ExceptionSpecificationType.h"
44#include "clang/Basic/FileManager.h"
45#include "clang/Basic/FileSystemOptions.h"
46#include "clang/Basic/IdentifierTable.h"
47#include "clang/Basic/LLVM.h"
48#include "clang/Basic/LangOptions.h"
49#include "clang/Basic/Module.h"
50#include "clang/Basic/ObjCRuntime.h"
51#include "clang/Basic/OperatorKinds.h"
52#include "clang/Basic/PragmaKinds.h"
53#include "clang/Basic/Sanitizers.h"
54#include "clang/Basic/SourceLocation.h"
55#include "clang/Basic/SourceManager.h"
56#include "clang/Basic/SourceManagerInternals.h"
57#include "clang/Basic/Specifiers.h"
58#include "clang/Basic/TargetInfo.h"
59#include "clang/Basic/TargetOptions.h"
60#include "clang/Basic/TokenKinds.h"
61#include "clang/Basic/Version.h"
62#include "clang/Lex/HeaderSearch.h"
63#include "clang/Lex/HeaderSearchOptions.h"
64#include "clang/Lex/MacroInfo.h"
65#include "clang/Lex/ModuleMap.h"
66#include "clang/Lex/PreprocessingRecord.h"
67#include "clang/Lex/Preprocessor.h"
68#include "clang/Lex/PreprocessorOptions.h"
69#include "clang/Lex/Token.h"
70#include "clang/Sema/ObjCMethodList.h"
71#include "clang/Sema/Scope.h"
72#include "clang/Sema/Sema.h"
73#include "clang/Sema/Weak.h"
74#include "clang/Serialization/ASTBitCodes.h"
75#include "clang/Serialization/ASTDeserializationListener.h"
76#include "clang/Serialization/ContinuousRangeMap.h"
77#include "clang/Serialization/GlobalModuleIndex.h"
78#include "clang/Serialization/InMemoryModuleCache.h"
79#include "clang/Serialization/Module.h"
80#include "clang/Serialization/ModuleFileExtension.h"
81#include "clang/Serialization/ModuleManager.h"
82#include "clang/Serialization/PCHContainerOperations.h"
83#include "clang/Serialization/SerializationDiagnostic.h"
84#include "llvm/ADT/APFloat.h"
85#include "llvm/ADT/APInt.h"
86#include "llvm/ADT/APSInt.h"
87#include "llvm/ADT/ArrayRef.h"
88#include "llvm/ADT/DenseMap.h"
89#include "llvm/ADT/FoldingSet.h"
90#include "llvm/ADT/Hashing.h"
91#include "llvm/ADT/IntrusiveRefCntPtr.h"
92#include "llvm/ADT/None.h"
93#include "llvm/ADT/Optional.h"
94#include "llvm/ADT/STLExtras.h"
95#include "llvm/ADT/ScopeExit.h"
96#include "llvm/ADT/SmallPtrSet.h"
97#include "llvm/ADT/SmallString.h"
98#include "llvm/ADT/SmallVector.h"
99#include "llvm/ADT/StringExtras.h"
100#include "llvm/ADT/StringMap.h"
101#include "llvm/ADT/StringRef.h"
102#include "llvm/ADT/Triple.h"
103#include "llvm/ADT/iterator_range.h"
104#include "llvm/Bitcode/BitstreamReader.h"
105#include "llvm/Support/Casting.h"
106#include "llvm/Support/Compiler.h"
107#include "llvm/Support/Compression.h"
108#include "llvm/Support/DJB.h"
109#include "llvm/Support/Endian.h"
110#include "llvm/Support/Error.h"
111#include "llvm/Support/ErrorHandling.h"
112#include "llvm/Support/FileSystem.h"
113#include "llvm/Support/MemoryBuffer.h"
114#include "llvm/Support/Path.h"
115#include "llvm/Support/SaveAndRestore.h"
116#include "llvm/Support/Timer.h"
117#include "llvm/Support/VersionTuple.h"
118#include "llvm/Support/raw_ostream.h"
119#include <algorithm>
120#include <cassert>
121#include <cstddef>
122#include <cstdint>
123#include <cstdio>
124#include <ctime>
125#include <iterator>
126#include <limits>
127#include <map>
128#include <memory>
129#include <string>
130#include <system_error>
131#include <tuple>
132#include <utility>
133#include <vector>
134
135using namespace clang;
136using namespace clang::serialization;
137using namespace clang::serialization::reader;
138using llvm::BitstreamCursor;
139
140//===----------------------------------------------------------------------===//
141// ChainedASTReaderListener implementation
142//===----------------------------------------------------------------------===//
143
144bool
145ChainedASTReaderListener::ReadFullVersionInformation(StringRef FullVersion) {
146 return First->ReadFullVersionInformation(FullVersion) ||
147 Second->ReadFullVersionInformation(FullVersion);
148}
149
150void ChainedASTReaderListener::ReadModuleName(StringRef ModuleName) {
151 First->ReadModuleName(ModuleName);
152 Second->ReadModuleName(ModuleName);
153}
154
155void ChainedASTReaderListener::ReadModuleMapFile(StringRef ModuleMapPath) {
156 First->ReadModuleMapFile(ModuleMapPath);
157 Second->ReadModuleMapFile(ModuleMapPath);
158}
159
160bool
161ChainedASTReaderListener::ReadLanguageOptions(const LangOptions &LangOpts,
162 bool Complain,
163 bool AllowCompatibleDifferences) {
164 return First->ReadLanguageOptions(LangOpts, Complain,
165 AllowCompatibleDifferences) ||
166 Second->ReadLanguageOptions(LangOpts, Complain,
167 AllowCompatibleDifferences);
168}
169
170bool ChainedASTReaderListener::ReadTargetOptions(
171 const TargetOptions &TargetOpts, bool Complain,
172 bool AllowCompatibleDifferences) {
173 return First->ReadTargetOptions(TargetOpts, Complain,
174 AllowCompatibleDifferences) ||
175 Second->ReadTargetOptions(TargetOpts, Complain,
176 AllowCompatibleDifferences);
177}
178
179bool ChainedASTReaderListener::ReadDiagnosticOptions(
180 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
181 return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
182 Second->ReadDiagnosticOptions(DiagOpts, Complain);
183}
184
185bool
186ChainedASTReaderListener::ReadFileSystemOptions(const FileSystemOptions &FSOpts,
187 bool Complain) {
188 return First->ReadFileSystemOptions(FSOpts, Complain) ||
189 Second->ReadFileSystemOptions(FSOpts, Complain);
190}
191
192bool ChainedASTReaderListener::ReadHeaderSearchOptions(
193 const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath,
194 bool Complain) {
195 return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
196 Complain) ||
197 Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
198 Complain);
199}
200
201bool ChainedASTReaderListener::ReadPreprocessorOptions(
202 const PreprocessorOptions &PPOpts, bool Complain,
203 std::string &SuggestedPredefines) {
204 return First->ReadPreprocessorOptions(PPOpts, Complain,
205 SuggestedPredefines) ||
206 Second->ReadPreprocessorOptions(PPOpts, Complain, SuggestedPredefines);
207}
208
209void ChainedASTReaderListener::ReadCounter(const serialization::ModuleFile &M,
210 unsigned Value) {
211 First->ReadCounter(M, Value);
212 Second->ReadCounter(M, Value);
213}
214
215bool ChainedASTReaderListener::needsInputFileVisitation() {
216 return First->needsInputFileVisitation() ||
217 Second->needsInputFileVisitation();
218}
219
220bool ChainedASTReaderListener::needsSystemInputFileVisitation() {
221 return First->needsSystemInputFileVisitation() ||
222 Second->needsSystemInputFileVisitation();
223}
224
225void ChainedASTReaderListener::visitModuleFile(StringRef Filename,
226 ModuleKind Kind) {
227 First->visitModuleFile(Filename, Kind);
228 Second->visitModuleFile(Filename, Kind);
229}
230
231bool ChainedASTReaderListener::visitInputFile(StringRef Filename,
232 bool isSystem,
233 bool isOverridden,
234 bool isExplicitModule) {
235 bool Continue = false;
236 if (First->needsInputFileVisitation() &&
237 (!isSystem || First->needsSystemInputFileVisitation()))
238 Continue |= First->visitInputFile(Filename, isSystem, isOverridden,
239 isExplicitModule);
240 if (Second->needsInputFileVisitation() &&
241 (!isSystem || Second->needsSystemInputFileVisitation()))
242 Continue |= Second->visitInputFile(Filename, isSystem, isOverridden,
243 isExplicitModule);
244 return Continue;
245}
246
247void ChainedASTReaderListener::readModuleFileExtension(
248 const ModuleFileExtensionMetadata &Metadata) {
249 First->readModuleFileExtension(Metadata);
250 Second->readModuleFileExtension(Metadata);
251}
252
253//===----------------------------------------------------------------------===//
254// PCH validator implementation
255//===----------------------------------------------------------------------===//
256
257ASTReaderListener::~ASTReaderListener() = default;
258
259/// Compare the given set of language options against an existing set of
260/// language options.
261///
262/// \param Diags If non-NULL, diagnostics will be emitted via this engine.
263/// \param AllowCompatibleDifferences If true, differences between compatible
264/// language options will be permitted.
265///
266/// \returns true if the languagae options mis-match, false otherwise.
267static bool checkLanguageOptions(const LangOptions &LangOpts,
268 const LangOptions &ExistingLangOpts,
269 DiagnosticsEngine *Diags,
270 bool AllowCompatibleDifferences = true) {
271#define LANGOPT(Name, Bits, Default, Description) \
272 if (ExistingLangOpts.Name != LangOpts.Name) { \
273 if (Diags) \
274 Diags->Report(diag::err_pch_langopt_mismatch) \
275 << Description << LangOpts.Name << ExistingLangOpts.Name; \
276 return true; \
277 }
278
279#define VALUE_LANGOPT(Name, Bits, Default, Description) \
280 if (ExistingLangOpts.Name != LangOpts.Name) { \
281 if (Diags) \
282 Diags->Report(diag::err_pch_langopt_value_mismatch) \
283 << Description; \
284 return true; \
285 }
286
287#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
288 if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
289 if (Diags) \
290 Diags->Report(diag::err_pch_langopt_value_mismatch) \
291 << Description; \
292 return true; \
293 }
294
295#define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
296 if (!AllowCompatibleDifferences) \
297 LANGOPT(Name, Bits, Default, Description)
298
299#define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
300 if (!AllowCompatibleDifferences) \
301 ENUM_LANGOPT(Name, Bits, Default, Description)
302
303#define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
304 if (!AllowCompatibleDifferences) \
305 VALUE_LANGOPT(Name, Bits, Default, Description)
306
307#define BENIGN_LANGOPT(Name, Bits, Default, Description)
308#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
309#define BENIGN_VALUE_LANGOPT(Name, Type, Bits, Default, Description)
310#include "clang/Basic/LangOptions.def"
311
312 if (ExistingLangOpts.ModuleFeatures != LangOpts.ModuleFeatures) {
313 if (Diags)
314 Diags->Report(diag::err_pch_langopt_value_mismatch) << "module features";
315 return true;
316 }
317
318 if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {
319 if (Diags)
320 Diags->Report(diag::err_pch_langopt_value_mismatch)
321 << "target Objective-C runtime";
322 return true;
323 }
324
325 if (ExistingLangOpts.CommentOpts.BlockCommandNames !=
326 LangOpts.CommentOpts.BlockCommandNames) {
327 if (Diags)
328 Diags->Report(diag::err_pch_langopt_value_mismatch)
329 << "block command names";
330 return true;
331 }
332
333 // Sanitizer feature mismatches are treated as compatible differences. If
334 // compatible differences aren't allowed, we still only want to check for
335 // mismatches of non-modular sanitizers (the only ones which can affect AST
336 // generation).
337 if (!AllowCompatibleDifferences) {
338 SanitizerMask ModularSanitizers = getPPTransparentSanitizers();
339 SanitizerSet ExistingSanitizers = ExistingLangOpts.Sanitize;
340 SanitizerSet ImportedSanitizers = LangOpts.Sanitize;
341 ExistingSanitizers.clear(ModularSanitizers);
342 ImportedSanitizers.clear(ModularSanitizers);
343 if (ExistingSanitizers.Mask != ImportedSanitizers.Mask) {
344 const std::string Flag = "-fsanitize=";
345 if (Diags) {
346#define SANITIZER(NAME, ID) \
347 { \
348 bool InExistingModule = ExistingSanitizers.has(SanitizerKind::ID); \
349 bool InImportedModule = ImportedSanitizers.has(SanitizerKind::ID); \
350 if (InExistingModule != InImportedModule) \
351 Diags->Report(diag::err_pch_targetopt_feature_mismatch) \
352 << InExistingModule << (Flag + NAME); \
353 }
354#include "clang/Basic/Sanitizers.def"
355 }
356 return true;
357 }
358 }
359
360 return false;
361}
362
363/// Compare the given set of target options against an existing set of
364/// target options.
365///
366/// \param Diags If non-NULL, diagnostics will be emitted via this engine.
367///
368/// \returns true if the target options mis-match, false otherwise.
369static bool checkTargetOptions(const TargetOptions &TargetOpts,
370 const TargetOptions &ExistingTargetOpts,
371 DiagnosticsEngine *Diags,
372 bool AllowCompatibleDifferences = true) {
373#define CHECK_TARGET_OPT(Field, Name) \
374 if (TargetOpts.Field != ExistingTargetOpts.Field) { \
375 if (Diags) \
376 Diags->Report(diag::err_pch_targetopt_mismatch) \
377 << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
378 return true; \
379 }
380
381 // The triple and ABI must match exactly.
382 CHECK_TARGET_OPT(Triple, "target");
383 CHECK_TARGET_OPT(ABI, "target ABI");
384
385 // We can tolerate different CPUs in many cases, notably when one CPU
386 // supports a strict superset of another. When allowing compatible
387 // differences skip this check.
388 if (!AllowCompatibleDifferences)
389 CHECK_TARGET_OPT(CPU, "target CPU");
390
391#undef CHECK_TARGET_OPT
392
393 // Compare feature sets.
394 SmallVector<StringRef, 4> ExistingFeatures(
395 ExistingTargetOpts.FeaturesAsWritten.begin(),
396 ExistingTargetOpts.FeaturesAsWritten.end());
397 SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
398 TargetOpts.FeaturesAsWritten.end());
399 llvm::sort(ExistingFeatures);
400 llvm::sort(ReadFeatures);
401
402 // We compute the set difference in both directions explicitly so that we can
403 // diagnose the differences differently.
404 SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures;
405 std::set_difference(
406 ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
407 ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
408 std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
409 ExistingFeatures.begin(), ExistingFeatures.end(),
410 std::back_inserter(UnmatchedReadFeatures));
411
412 // If we are allowing compatible differences and the read feature set is
413 // a strict subset of the existing feature set, there is nothing to diagnose.
414 if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
415 return false;
416
417 if (Diags) {
418 for (StringRef Feature : UnmatchedReadFeatures)
419 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
420 << /* is-existing-feature */ false << Feature;
421 for (StringRef Feature : UnmatchedExistingFeatures)
422 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
423 << /* is-existing-feature */ true << Feature;
424 }
425
426 return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
427}
428
429bool
430PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts,
431 bool Complain,
432 bool AllowCompatibleDifferences) {
433 const LangOptions &ExistingLangOpts = PP.getLangOpts();
434 return checkLanguageOptions(LangOpts, ExistingLangOpts,
435 Complain ? &Reader.Diags : nullptr,
436 AllowCompatibleDifferences);
437}
438
439bool PCHValidator::ReadTargetOptions(const TargetOptions &TargetOpts,
440 bool Complain,
441 bool AllowCompatibleDifferences) {
442 const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();
443 return checkTargetOptions(TargetOpts, ExistingTargetOpts,
444 Complain ? &Reader.Diags : nullptr,
445 AllowCompatibleDifferences);
446}
447
448namespace {
449
450using MacroDefinitionsMap =
451 llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>;
452using DeclsMap = llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8>>;
453
454} // namespace
455
456static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags,
457 DiagnosticsEngine &Diags,
458 bool Complain) {
459 using Level = DiagnosticsEngine::Level;
460
461 // Check current mappings for new -Werror mappings, and the stored mappings
462 // for cases that were explicitly mapped to *not* be errors that are now
463 // errors because of options like -Werror.
464 DiagnosticsEngine *MappingSources[] = { &Diags, &StoredDiags };
465
466 for (DiagnosticsEngine *MappingSource : MappingSources) {
467 for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
468 diag::kind DiagID = DiagIDMappingPair.first;
469 Level CurLevel = Diags.getDiagnosticLevel(DiagID, SourceLocation());
470 if (CurLevel < DiagnosticsEngine::Error)
471 continue; // not significant
472 Level StoredLevel =
473 StoredDiags.getDiagnosticLevel(DiagID, SourceLocation());
474 if (StoredLevel < DiagnosticsEngine::Error) {
475 if (Complain)
476 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror=" +
477 Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str();
478 return true;
479 }
480 }
481 }
482
483 return false;
484}
485
486static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags) {
487 diag::Severity Ext = Diags.getExtensionHandlingBehavior();
488 if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors())
489 return true;
490 return Ext >= diag::Severity::Error;
491}
492
493static bool checkDiagnosticMappings(DiagnosticsEngine &StoredDiags,
494 DiagnosticsEngine &Diags,
495 bool IsSystem, bool Complain) {
496 // Top-level options
497 if (IsSystem) {
498 if (Diags.getSuppressSystemWarnings())
499 return false;
500 // If -Wsystem-headers was not enabled before, be conservative
501 if (StoredDiags.getSuppressSystemWarnings()) {
502 if (Complain)
503 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Wsystem-headers";
504 return true;
505 }
506 }
507
508 if (Diags.getWarningsAsErrors() && !StoredDiags.getWarningsAsErrors()) {
509 if (Complain)
510 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror";
511 return true;
512 }
513
514 if (Diags.getWarningsAsErrors() && Diags.getEnableAllWarnings() &&
515 !StoredDiags.getEnableAllWarnings()) {
516 if (Complain)
517 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Weverything -Werror";
518 return true;
519 }
520
521 if (isExtHandlingFromDiagsError(Diags) &&
522 !isExtHandlingFromDiagsError(StoredDiags)) {
523 if (Complain)
524 Diags.Report(diag::err_pch_diagopt_mismatch) << "-pedantic-errors";
525 return true;
526 }
527
528 return checkDiagnosticGroupMappings(StoredDiags, Diags, Complain);
529}
530
531/// Return the top import module if it is implicit, nullptr otherwise.
532static Module *getTopImportImplicitModule(ModuleManager &ModuleMgr,
533 Preprocessor &PP) {
534 // If the original import came from a file explicitly generated by the user,
535 // don't check the diagnostic mappings.
536 // FIXME: currently this is approximated by checking whether this is not a
537 // module import of an implicitly-loaded module file.
538 // Note: ModuleMgr.rbegin() may not be the current module, but it must be in
539 // the transitive closure of its imports, since unrelated modules cannot be
540 // imported until after this module finishes validation.
541 ModuleFile *TopImport = &*ModuleMgr.rbegin();
542 while (!TopImport->ImportedBy.empty())
543 TopImport = TopImport->ImportedBy[0];
544 if (TopImport->Kind != MK_ImplicitModule)
545 return nullptr;
546
547 StringRef ModuleName = TopImport->ModuleName;
548 assert(!ModuleName.empty() && "diagnostic options read before module name");
549
550 Module *M = PP.getHeaderSearchInfo().lookupModule(ModuleName);
551 assert(M && "missing module");
552 return M;
553}
554
555bool PCHValidator::ReadDiagnosticOptions(
556 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
557 DiagnosticsEngine &ExistingDiags = PP.getDiagnostics();
558 IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(ExistingDiags.getDiagnosticIDs());
559 IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
560 new DiagnosticsEngine(DiagIDs, DiagOpts.get()));
561 // This should never fail, because we would have processed these options
562 // before writing them to an ASTFile.
563 ProcessWarningOptions(*Diags, *DiagOpts, /*Report*/false);
564
565 ModuleManager &ModuleMgr = Reader.getModuleManager();
566 assert(ModuleMgr.size() >= 1 && "what ASTFile is this then");
567
568 Module *TopM = getTopImportImplicitModule(ModuleMgr, PP);
569 if (!TopM)
570 return false;
571
572 // FIXME: if the diagnostics are incompatible, save a DiagnosticOptions that
573 // contains the union of their flags.
574 return checkDiagnosticMappings(*Diags, ExistingDiags, TopM->IsSystem,
575 Complain);
576}
577
578/// Collect the macro definitions provided by the given preprocessor
579/// options.
580static void
581collectMacroDefinitions(const PreprocessorOptions &PPOpts,
582 MacroDefinitionsMap &Macros,
583 SmallVectorImpl<StringRef> *MacroNames = nullptr) {
584 for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
585 StringRef Macro = PPOpts.Macros[I].first;
586 bool IsUndef = PPOpts.Macros[I].second;
587
588 std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
589 StringRef MacroName = MacroPair.first;
590 StringRef MacroBody = MacroPair.second;
591
592 // For an #undef'd macro, we only care about the name.
593 if (IsUndef) {
594 if (MacroNames && !Macros.count(MacroName))
595 MacroNames->push_back(MacroName);
596
597 Macros[MacroName] = std::make_pair("", true);
598 continue;
599 }
600
601 // For a #define'd macro, figure out the actual definition.
602 if (MacroName.size() == Macro.size())
603 MacroBody = "1";
604 else {
605 // Note: GCC drops anything following an end-of-line character.
606 StringRef::size_type End = MacroBody.find_first_of("\n\r");
607 MacroBody = MacroBody.substr(0, End);
608 }
609
610 if (MacroNames && !Macros.count(MacroName))
611 MacroNames->push_back(MacroName);
612 Macros[MacroName] = std::make_pair(MacroBody, false);
613 }
614}
615
616/// Check the preprocessor options deserialized from the control block
617/// against the preprocessor options in an existing preprocessor.
618///
619/// \param Diags If non-null, produce diagnostics for any mismatches incurred.
620/// \param Validate If true, validate preprocessor options. If false, allow
621/// macros defined by \p ExistingPPOpts to override those defined by
622/// \p PPOpts in SuggestedPredefines.
623static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts,
624 const PreprocessorOptions &ExistingPPOpts,
625 DiagnosticsEngine *Diags,
626 FileManager &FileMgr,
627 std::string &SuggestedPredefines,
628 const LangOptions &LangOpts,
629 bool Validate = true) {
630 // Check macro definitions.
631 MacroDefinitionsMap ASTFileMacros;
632 collectMacroDefinitions(PPOpts, ASTFileMacros);
633 MacroDefinitionsMap ExistingMacros;
634 SmallVector<StringRef, 4> ExistingMacroNames;
635 collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames);
636
637 for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
638 // Dig out the macro definition in the existing preprocessor options.
639 StringRef MacroName = ExistingMacroNames[I];
640 std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
641
642 // Check whether we know anything about this macro name or not.
643 llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>::iterator Known =
644 ASTFileMacros.find(MacroName);
645 if (!Validate || Known == ASTFileMacros.end()) {
646 // FIXME: Check whether this identifier was referenced anywhere in the
647 // AST file. If so, we should reject the AST file. Unfortunately, this
648 // information isn't in the control block. What shall we do about it?
649
650 if (Existing.second) {
651 SuggestedPredefines += "#undef ";
652 SuggestedPredefines += MacroName.str();
653 SuggestedPredefines += '\n';
654 } else {
655 SuggestedPredefines += "#define ";
656 SuggestedPredefines += MacroName.str();
657 SuggestedPredefines += ' ';
658 SuggestedPredefines += Existing.first.str();
659 SuggestedPredefines += '\n';
660 }
661 continue;
662 }
663
664 // If the macro was defined in one but undef'd in the other, we have a
665 // conflict.
666 if (Existing.second != Known->second.second) {
667 if (Diags) {
668 Diags->Report(diag::err_pch_macro_def_undef)
669 << MacroName << Known->second.second;
670 }
671 return true;
672 }
673
674 // If the macro was #undef'd in both, or if the macro bodies are identical,
675 // it's fine.
676 if (Existing.second || Existing.first == Known->second.first)
677 continue;
678
679 // The macro bodies differ; complain.
680 if (Diags) {
681 Diags->Report(diag::err_pch_macro_def_conflict)
682 << MacroName << Known->second.first << Existing.first;
683 }
684 return true;
685 }
686
687 // Check whether we're using predefines.
688 if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines && Validate) {
689 if (Diags) {
690 Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
691 }
692 return true;
693 }
694
695 // Detailed record is important since it is used for the module cache hash.
696 if (LangOpts.Modules &&
697 PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord && Validate) {
698 if (Diags) {
699 Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord;
700 }
701 return true;
702 }
703
704 // Compute the #include and #include_macros lines we need.
705 for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {
706 StringRef File = ExistingPPOpts.Includes[I];
707
708 if (!ExistingPPOpts.ImplicitPCHInclude.empty() &&
709 !ExistingPPOpts.PCHThroughHeader.empty()) {
710 // In case the through header is an include, we must add all the includes
711 // to the predefines so the start point can be determined.
712 SuggestedPredefines += "#include \"";
713 SuggestedPredefines += File;
714 SuggestedPredefines += "\"\n";
715 continue;
716 }
717
718 if (File == ExistingPPOpts.ImplicitPCHInclude)
719 continue;
720
721 if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File)
722 != PPOpts.Includes.end())
723 continue;
724
725 SuggestedPredefines += "#include \"";
726 SuggestedPredefines += File;
727 SuggestedPredefines += "\"\n";
728 }
729
730 for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
731 StringRef File = ExistingPPOpts.MacroIncludes[I];
732 if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(),
733 File)
734 != PPOpts.MacroIncludes.end())
735 continue;
736
737 SuggestedPredefines += "#__include_macros \"";
738 SuggestedPredefines += File;
739 SuggestedPredefines += "\"\n##\n";
740 }
741
742 return false;
743}
744
745bool PCHValidator::ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
746 bool Complain,
747 std::string &SuggestedPredefines) {
748 const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();
749
750 return checkPreprocessorOptions(PPOpts, ExistingPPOpts,
751 Complain? &Reader.Diags : nullptr,
752 PP.getFileManager(),
753 SuggestedPredefines,
754 PP.getLangOpts());
755}
756
757bool SimpleASTReaderListener::ReadPreprocessorOptions(
758 const PreprocessorOptions &PPOpts,
759 bool Complain,
760 std::string &SuggestedPredefines) {
761 return checkPreprocessorOptions(PPOpts,
762 PP.getPreprocessorOpts(),
763 nullptr,
764 PP.getFileManager(),
765 SuggestedPredefines,
766 PP.getLangOpts(),
767 false);
768}
769
770/// Check the header search options deserialized from the control block
771/// against the header search options in an existing preprocessor.
772///
773/// \param Diags If non-null, produce diagnostics for any mismatches incurred.
774static bool checkHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
775 StringRef SpecificModuleCachePath,
776 StringRef ExistingModuleCachePath,
777 DiagnosticsEngine *Diags,
778 const LangOptions &LangOpts) {
779 if (LangOpts.Modules) {
780 if (SpecificModuleCachePath != ExistingModuleCachePath) {
781 if (Diags)
782 Diags->Report(diag::err_pch_modulecache_mismatch)
783 << SpecificModuleCachePath << ExistingModuleCachePath;
784 return true;
785 }
786 }
787
788 return false;
789}
790
791bool PCHValidator::ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
792 StringRef SpecificModuleCachePath,
793 bool Complain) {
794 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
795 PP.getHeaderSearchInfo().getModuleCachePath(),
796 Complain ? &Reader.Diags : nullptr,
797 PP.getLangOpts());
798}
799
800void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {
801 PP.setCounterValue(Value);
802}
803
804//===----------------------------------------------------------------------===//
805// AST reader implementation
806//===----------------------------------------------------------------------===//
807
808void ASTReader::setDeserializationListener(ASTDeserializationListener *Listener,
809 bool TakeOwnership) {
810 DeserializationListener = Listener;
811 OwnsDeserializationListener = TakeOwnership;
812}
813
814unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) {
815 return serialization::ComputeHash(Sel);
816}
817
818std::pair<unsigned, unsigned>
819ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
820 using namespace llvm::support;
821
822 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
823 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
824 return std::make_pair(KeyLen, DataLen);
825}
826
827ASTSelectorLookupTrait::internal_key_type
828ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
829 using namespace llvm::support;
830
831 SelectorTable &SelTable = Reader.getContext().Selectors;
832 unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
833 IdentifierInfo *FirstII = Reader.getLocalIdentifier(
834 F, endian::readNext<uint32_t, little, unaligned>(d));
835 if (N == 0)
836 return SelTable.getNullarySelector(FirstII);
837 else if (N == 1)
838 return SelTable.getUnarySelector(FirstII);
839
840 SmallVector<IdentifierInfo *, 16> Args;
841 Args.push_back(FirstII);
842 for (unsigned I = 1; I != N; ++I)
843 Args.push_back(Reader.getLocalIdentifier(
844 F, endian::readNext<uint32_t, little, unaligned>(d)));
845
846 return SelTable.getSelector(N, Args.data());
847}
848
849ASTSelectorLookupTrait::data_type
850ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d,
851 unsigned DataLen) {
852 using namespace llvm::support;
853
854 data_type Result;
855
856 Result.ID = Reader.getGlobalSelectorID(
857 F, endian::readNext<uint32_t, little, unaligned>(d));
858 unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
859 unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
860 Result.InstanceBits = FullInstanceBits & 0x3;
861 Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
862 Result.FactoryBits = FullFactoryBits & 0x3;
863 Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
864 unsigned NumInstanceMethods = FullInstanceBits >> 3;
865 unsigned NumFactoryMethods = FullFactoryBits >> 3;
866
867 // Load instance methods
868 for (unsigned I = 0; I != NumInstanceMethods; ++I) {
869 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
870 F, endian::readNext<uint32_t, little, unaligned>(d)))
871 Result.Instance.push_back(Method);
872 }
873
874 // Load factory methods
875 for (unsigned I = 0; I != NumFactoryMethods; ++I) {
876 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
877 F, endian::readNext<uint32_t, little, unaligned>(d)))
878 Result.Factory.push_back(Method);
879 }
880
881 return Result;
882}
883
884unsigned ASTIdentifierLookupTraitBase::ComputeHash(const internal_key_type& a) {
885 return llvm::djbHash(a);
886}
887
888std::pair<unsigned, unsigned>
889ASTIdentifierLookupTraitBase::ReadKeyDataLength(const unsigned char*& d) {
890 using namespace llvm::support;
891
892 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
893 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
894 return std::make_pair(KeyLen, DataLen);
895}
896
897ASTIdentifierLookupTraitBase::internal_key_type
898ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) {
899 assert(n >= 2 && d[n-1] == '\0');
900 return StringRef((const char*) d, n-1);
901}
902
903/// Whether the given identifier is "interesting".
904static bool isInterestingIdentifier(ASTReader &Reader, IdentifierInfo &II,
905 bool IsModule) {
906 return II.hadMacroDefinition() ||
907 II.isPoisoned() ||
908 (IsModule ? II.hasRevertedBuiltin() : II.getObjCOrBuiltinID()) ||
909 II.hasRevertedTokenIDToIdentifier() ||
910 (!(IsModule && Reader.getPreprocessor().getLangOpts().CPlusPlus) &&
911 II.getFETokenInfo());
912}
913
914static bool readBit(unsigned &Bits) {
915 bool Value = Bits & 0x1;
916 Bits >>= 1;
917 return Value;
918}
919
920IdentID ASTIdentifierLookupTrait::ReadIdentifierID(const unsigned char *d) {
921 using namespace llvm::support;
922
923 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
924 return Reader.getGlobalIdentifierID(F, RawID >> 1);
925}
926
927static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II) {
928 if (!II.isFromAST()) {
929 II.setIsFromAST();
930 bool IsModule = Reader.getPreprocessor().getCurrentModule() != nullptr;
931 if (isInterestingIdentifier(Reader, II, IsModule))
932 II.setChangedSinceDeserialization();
933 }
934}
935
936IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
937 const unsigned char* d,
938 unsigned DataLen) {
939 using namespace llvm::support;
940
941 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
942 bool IsInteresting = RawID & 0x01;
943
944 // Wipe out the "is interesting" bit.
945 RawID = RawID >> 1;
946
947 // Build the IdentifierInfo and link the identifier ID with it.
948 IdentifierInfo *II = KnownII;
949 if (!II) {
950 II = &Reader.getIdentifierTable().getOwn(k);
951 KnownII = II;
952 }
953 markIdentifierFromAST(Reader, *II);
954 Reader.markIdentifierUpToDate(II);
955
956 IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
957 if (!IsInteresting) {
958 // For uninteresting identifiers, there's nothing else to do. Just notify
959 // the reader that we've finished loading this identifier.
960 Reader.SetIdentifierInfo(ID, II);
961 return II;
962 }
963
964 unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
965 unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
966 bool CPlusPlusOperatorKeyword = readBit(Bits);
967 bool HasRevertedTokenIDToIdentifier = readBit(Bits);
968 bool HasRevertedBuiltin = readBit(Bits);
969 bool Poisoned = readBit(Bits);
970 bool ExtensionToken = readBit(Bits);
971 bool HadMacroDefinition = readBit(Bits);
972
973 assert(Bits == 0 && "Extra bits in the identifier?");
974 DataLen -= 8;
975
976 // Set or check the various bits in the IdentifierInfo structure.
977 // Token IDs are read-only.
978 if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier)
979 II->revertTokenIDToIdentifier();
980 if (!F.isModule())
981 II->setObjCOrBuiltinID(ObjCOrBuiltinID);
982 else if (HasRevertedBuiltin && II->getBuiltinID()) {
983 II->revertBuiltin();
984 assert((II->hasRevertedBuiltin() ||
985 II->getObjCOrBuiltinID() == ObjCOrBuiltinID) &&
986 "Incorrect ObjC keyword or builtin ID");
987 }
988 assert(II->isExtensionToken() == ExtensionToken &&
989 "Incorrect extension token flag");
990 (void)ExtensionToken;
991 if (Poisoned)
992 II->setIsPoisoned(true);
993 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
994 "Incorrect C++ operator keyword flag");
995 (void)CPlusPlusOperatorKeyword;
996
997 // If this identifier is a macro, deserialize the macro
998 // definition.
999 if (HadMacroDefinition) {
1000 uint32_t MacroDirectivesOffset =
1001 endian::readNext<uint32_t, little, unaligned>(d);
1002 DataLen -= 4;
1003
1004 Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
1005 }
1006
1007 Reader.SetIdentifierInfo(ID, II);
1008
1009 // Read all of the declarations visible at global scope with this
1010 // name.
1011 if (DataLen > 0) {
1012 SmallVector<uint32_t, 4> DeclIDs;
1013 for (; DataLen > 0; DataLen -= 4)
1014 DeclIDs.push_back(Reader.getGlobalDeclID(
1015 F, endian::readNext<uint32_t, little, unaligned>(d)));
1016 Reader.SetGloballyVisibleDecls(II, DeclIDs);
1017 }
1018
1019 return II;
1020}
1021
1022DeclarationNameKey::DeclarationNameKey(DeclarationName Name)
1023 : Kind(Name.getNameKind()) {
1024 switch (Kind) {
1025 case DeclarationName::Identifier:
1026 Data = (uint64_t)Name.getAsIdentifierInfo();
1027 break;
1028 case DeclarationName::ObjCZeroArgSelector:
1029 case DeclarationName::ObjCOneArgSelector:
1030 case DeclarationName::ObjCMultiArgSelector:
1031 Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
1032 break;
1033 case DeclarationName::CXXOperatorName:
1034 Data = Name.getCXXOverloadedOperator();
1035 break;
1036 case DeclarationName::CXXLiteralOperatorName:
1037 Data = (uint64_t)Name.getCXXLiteralIdentifier();
1038 break;
1039 case DeclarationName::CXXDeductionGuideName:
1040 Data = (uint64_t)Name.getCXXDeductionGuideTemplate()
1041 ->getDeclName().getAsIdentifierInfo();
1042 break;
1043 case DeclarationName::CXXConstructorName:
1044 case DeclarationName::CXXDestructorName:
1045 case DeclarationName::CXXConversionFunctionName:
1046 case DeclarationName::CXXUsingDirective:
1047 Data = 0;
1048 break;
1049 }
1050}
1051
1052unsigned DeclarationNameKey::getHash() const {
1053 llvm::FoldingSetNodeID ID;
1054 ID.AddInteger(Kind);
1055
1056 switch (Kind) {
1057 case DeclarationName::Identifier:
1058 case DeclarationName::CXXLiteralOperatorName:
1059 case DeclarationName::CXXDeductionGuideName:
1060 ID.AddString(((IdentifierInfo*)Data)->getName());
1061 break;
1062 case DeclarationName::ObjCZeroArgSelector:
1063 case DeclarationName::ObjCOneArgSelector:
1064 case DeclarationName::ObjCMultiArgSelector:
1065 ID.AddInteger(serialization::ComputeHash(Selector(Data)));
1066 break;
1067 case DeclarationName::CXXOperatorName:
1068 ID.AddInteger((OverloadedOperatorKind)Data);
1069 break;
1070 case DeclarationName::CXXConstructorName:
1071 case DeclarationName::CXXDestructorName:
1072 case DeclarationName::CXXConversionFunctionName:
1073 case DeclarationName::CXXUsingDirective:
1074 break;
1075 }
1076
1077 return ID.ComputeHash();
1078}
1079
1080ModuleFile *
1081ASTDeclContextNameLookupTrait::ReadFileRef(const unsigned char *&d) {
1082 using namespace llvm::support;
1083
1084 uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
1085 return Reader.getLocalModuleFile(F, ModuleFileID);
1086}
1087
1088std::pair<unsigned, unsigned>
1089ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char *&d) {
1090 using namespace llvm::support;
1091
1092 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
1093 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
1094 return std::make_pair(KeyLen, DataLen);
1095}
1096
1097ASTDeclContextNameLookupTrait::internal_key_type
1098ASTDeclContextNameLookupTrait::ReadKey(const unsigned char *d, unsigned) {
1099 using namespace llvm::support;
1100
1101 auto Kind = (DeclarationName::NameKind)*d++;
1102 uint64_t Data;
1103 switch (Kind) {
1104 case DeclarationName::Identifier:
1105 case DeclarationName::CXXLiteralOperatorName:
1106 case DeclarationName::CXXDeductionGuideName:
1107 Data = (uint64_t)Reader.getLocalIdentifier(
1108 F, endian::readNext<uint32_t, little, unaligned>(d));
1109 break;
1110 case DeclarationName::ObjCZeroArgSelector:
1111 case DeclarationName::ObjCOneArgSelector:
1112 case DeclarationName::ObjCMultiArgSelector:
1113 Data =
1114 (uint64_t)Reader.getLocalSelector(
1115 F, endian::readNext<uint32_t, little, unaligned>(
1116 d)).getAsOpaquePtr();
1117 break;
1118 case DeclarationName::CXXOperatorName:
1119 Data = *d++; // OverloadedOperatorKind
1120 break;
1121 case DeclarationName::CXXConstructorName:
1122 case DeclarationName::CXXDestructorName:
1123 case DeclarationName::CXXConversionFunctionName:
1124 case DeclarationName::CXXUsingDirective:
1125 Data = 0;
1126 break;
1127 }
1128
1129 return DeclarationNameKey(Kind, Data);
1130}
1131
1132void ASTDeclContextNameLookupTrait::ReadDataInto(internal_key_type,
1133 const unsigned char *d,
1134 unsigned DataLen,
1135 data_type_builder &Val) {
1136 using namespace llvm::support;
1137
1138 for (unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
1139 uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
1140 Val.insert(Reader.getGlobalDeclID(F, LocalID));
1141 }
1142}
1143
1144bool ASTReader::ReadLexicalDeclContextStorage(ModuleFile &M,
1145 BitstreamCursor &Cursor,
1146 uint64_t Offset,
1147 DeclContext *DC) {
1148 assert(Offset != 0);
1149
1150 SavedStreamPosition SavedPosition(Cursor);
1151 Cursor.JumpToBit(Offset);
1152
1153 RecordData Record;
1154 StringRef Blob;
1155 unsigned Code = Cursor.ReadCode();
1156 unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1157 if (RecCode != DECL_CONTEXT_LEXICAL) {
1158 Error("Expected lexical block");
1159 return true;
1160 }
1161
1162 assert(!isa<TranslationUnitDecl>(DC) &&
1163 "expected a TU_UPDATE_LEXICAL record for TU");
1164 // If we are handling a C++ class template instantiation, we can see multiple
1165 // lexical updates for the same record. It's important that we select only one
1166 // of them, so that field numbering works properly. Just pick the first one we
1167 // see.
1168 auto &Lex = LexicalDecls[DC];
1169 if (!Lex.first) {
1170 Lex = std::make_pair(
1171 &M, llvm::makeArrayRef(
1172 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
1173 Blob.data()),
1174 Blob.size() / 4));
1175 }
1176 DC->setHasExternalLexicalStorage(true);
1177 return false;
1178}
1179
1180bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
1181 BitstreamCursor &Cursor,
1182 uint64_t Offset,
1183 DeclID ID) {
1184 assert(Offset != 0);
1185
1186 SavedStreamPosition SavedPosition(Cursor);
1187 Cursor.JumpToBit(Offset);
1188
1189 RecordData Record;
1190 StringRef Blob;
1191 unsigned Code = Cursor.ReadCode();
1192 unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1193 if (RecCode != DECL_CONTEXT_VISIBLE) {
1194 Error("Expected visible lookup table block");
1195 return true;
1196 }
1197
1198 // We can't safely determine the primary context yet, so delay attaching the
1199 // lookup table until we're done with recursive deserialization.
1200 auto *Data = (const unsigned char*)Blob.data();
1201 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&M, Data});
1202 return false;
1203}
1204
1205void ASTReader::Error(StringRef Msg) const {
1206 Error(diag::err_fe_pch_malformed, Msg);
1207 if (PP.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1208 !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1209 Diag(diag::note_module_cache_path)
1210 << PP.getHeaderSearchInfo().getModuleCachePath();
1211 }
1212}
1213
1214void ASTReader::Error(unsigned DiagID,
1215 StringRef Arg1, StringRef Arg2) const {
1216 if (Diags.isDiagnosticInFlight())
1217 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
1218 else
1219 Diag(DiagID) << Arg1 << Arg2;
1220}
1221
1222//===----------------------------------------------------------------------===//
1223// Source Manager Deserialization
1224//===----------------------------------------------------------------------===//
1225
1226/// Read the line table in the source manager block.
1227/// \returns true if there was an error.
1228bool ASTReader::ParseLineTable(ModuleFile &F,
1229 const RecordData &Record) {
1230 unsigned Idx = 0;
1231 LineTableInfo &LineTable = SourceMgr.getLineTable();
1232
1233 // Parse the file names
1234 std::map<int, int> FileIDs;
1235 FileIDs[-1] = -1; // For unspecified filenames.
1236 for (unsigned I = 0; Record[Idx]; ++I) {
1237 // Extract the file name
1238 auto Filename = ReadPath(F, Record, Idx);
1239 FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
1240 }
1241 ++Idx;
1242
1243 // Parse the line entries
1244 std::vector<LineEntry> Entries;
1245 while (Idx < Record.size()) {
1246 int FID = Record[Idx++];
1247 assert(FID >= 0 && "Serialized line entries for non-local file.");
1248 // Remap FileID from 1-based old view.
1249 FID += F.SLocEntryBaseID - 1;
1250
1251 // Extract the line entries
1252 unsigned NumEntries = Record[Idx++];
1253 assert(NumEntries && "no line entries for file ID");
1254 Entries.clear();
1255 Entries.reserve(NumEntries);
1256 for (unsigned I = 0; I != NumEntries; ++I) {
1257 unsigned FileOffset = Record[Idx++];
1258 unsigned LineNo = Record[Idx++];
1259 int FilenameID = FileIDs[Record[Idx++]];
1260 SrcMgr::CharacteristicKind FileKind
1261 = (SrcMgr::CharacteristicKind)Record[Idx++];
1262 unsigned IncludeOffset = Record[Idx++];
1263 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1264 FileKind, IncludeOffset));
1265 }
1266 LineTable.AddEntry(FileID::get(FID), Entries);
1267 }
1268
1269 return false;
1270}
1271
1272/// Read a source manager block
1273bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
1274 using namespace SrcMgr;
1275
1276 BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
1277
1278 // Set the source-location entry cursor to the current position in
1279 // the stream. This cursor will be used to read the contents of the
1280 // source manager block initially, and then lazily read
1281 // source-location entries as needed.
1282 SLocEntryCursor = F.Stream;
1283
1284 // The stream itself is going to skip over the source manager block.
1285 if (F.Stream.SkipBlock()) {
1286 Error("malformed block record in AST file");
1287 return true;
1288 }
1289
1290 // Enter the source manager block.
1291 if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
1292 Error("malformed source manager block record in AST file");
1293 return true;
1294 }
1295
1296 RecordData Record;
1297 while (true) {
1298 llvm::BitstreamEntry E = SLocEntryCursor.advanceSkippingSubblocks();
1299
1300 switch (E.Kind) {
1301 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1302 case llvm::BitstreamEntry::Error:
1303 Error("malformed block record in AST file");
1304 return true;
1305 case llvm::BitstreamEntry::EndBlock:
1306 return false;
1307 case llvm::BitstreamEntry::Record:
1308 // The interesting case.
1309 break;
1310 }
1311
1312 // Read a record.
1313 Record.clear();
1314 StringRef Blob;
1315 switch (SLocEntryCursor.readRecord(E.ID, Record, &Blob)) {
1316 default: // Default behavior: ignore.
1317 break;
1318
1319 case SM_SLOC_FILE_ENTRY:
1320 case SM_SLOC_BUFFER_ENTRY:
1321 case SM_SLOC_EXPANSION_ENTRY:
1322 // Once we hit one of the source location entries, we're done.
1323 return false;
1324 }
1325 }
1326}
1327
1328/// If a header file is not found at the path that we expect it to be
1329/// and the PCH file was moved from its original location, try to resolve the
1330/// file by assuming that header+PCH were moved together and the header is in
1331/// the same place relative to the PCH.
1332static std::string
1333resolveFileRelativeToOriginalDir(const std::string &Filename,
1334 const std::string &OriginalDir,
1335 const std::string &CurrDir) {
1336 assert(OriginalDir != CurrDir &&
1337 "No point trying to resolve the file if the PCH dir didn't change");
1338
1339 using namespace llvm::sys;
1340
1341 SmallString<128> filePath(Filename);
1342 fs::make_absolute(filePath);
1343 assert(path::is_absolute(OriginalDir));
1344 SmallString<128> currPCHPath(CurrDir);
1345
1346 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1347 fileDirE = path::end(path::parent_path(filePath));
1348 path::const_iterator origDirI = path::begin(OriginalDir),
1349 origDirE = path::end(OriginalDir);
1350 // Skip the common path components from filePath and OriginalDir.
1351 while (fileDirI != fileDirE && origDirI != origDirE &&
1352 *fileDirI == *origDirI) {
1353 ++fileDirI;
1354 ++origDirI;
1355 }
1356 for (; origDirI != origDirE; ++origDirI)
1357 path::append(currPCHPath, "..");
1358 path::append(currPCHPath, fileDirI, fileDirE);
1359 path::append(currPCHPath, path::filename(Filename));
1360 return currPCHPath.str();
1361}
1362
1363bool ASTReader::ReadSLocEntry(int ID) {
1364 if (ID == 0)
1365 return false;
1366
1367 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1368 Error("source location entry ID out-of-range for AST file");
1369 return true;
1370 }
1371
1372 // Local helper to read the (possibly-compressed) buffer data following the
1373 // entry record.
1374 auto ReadBuffer = [this](
1375 BitstreamCursor &SLocEntryCursor,
1376 StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1377 RecordData Record;
1378 StringRef Blob;
1379 unsigned Code = SLocEntryCursor.ReadCode();
1380 unsigned RecCode = SLocEntryCursor.readRecord(Code, Record, &Blob);
1381
1382 if (RecCode == SM_SLOC_BUFFER_BLOB_COMPRESSED) {
1383 if (!llvm::zlib::isAvailable()) {
1384 Error("zlib is not available");
1385 return nullptr;
1386 }
1387 SmallString<0> Uncompressed;
1388 if (llvm::Error E =
1389 llvm::zlib::uncompress(Blob, Uncompressed, Record[0])) {
1390 Error("could not decompress embedded file contents: " +
1391 llvm::toString(std::move(E)));
1392 return nullptr;
1393 }
1394 return llvm::MemoryBuffer::getMemBufferCopy(Uncompressed, Name);
1395 } else if (RecCode == SM_SLOC_BUFFER_BLOB) {
1396 return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name, true);
1397 } else {
1398 Error("AST record has invalid code");
1399 return nullptr;
1400 }
1401 };
1402
1403 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1404 F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);
1405 BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
1406 unsigned BaseOffset = F->SLocEntryBaseOffset;
1407
1408 ++NumSLocEntriesRead;
1409 llvm::BitstreamEntry Entry = SLocEntryCursor.advance();
1410 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1411 Error("incorrectly-formatted source location entry in AST file");
1412 return true;
1413 }
1414
1415 RecordData Record;
1416 StringRef Blob;
1417 switch (SLocEntryCursor.readRecord(Entry.ID, Record, &Blob)) {
1418 default:
1419 Error("incorrectly-formatted source location entry in AST file");
1420 return true;
1421
1422 case SM_SLOC_FILE_ENTRY: {
1423 // We will detect whether a file changed and return 'Failure' for it, but
1424 // we will also try to fail gracefully by setting up the SLocEntry.
1425 unsigned InputID = Record[4];
1426 InputFile IF = getInputFile(*F, InputID);
1427 const FileEntry *File = IF.getFile();
1428 bool OverriddenBuffer = IF.isOverridden();
1429
1430 // Note that we only check if a File was returned. If it was out-of-date
1431 // we have complained but we will continue creating a FileID to recover
1432 // gracefully.
1433 if (!File)
1434 return true;
1435
1436 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1437 if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
1438 // This is the module's main file.
1439 IncludeLoc = getImportLocation(F);
1440 }
1441 SrcMgr::CharacteristicKind
1442 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1443 FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter,
1444 ID, BaseOffset + Record[0]);
1445 SrcMgr::FileInfo &FileInfo =
1446 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
1447 FileInfo.NumCreatedFIDs = Record[5];
1448 if (Record[3])
1449 FileInfo.setHasLineDirectives();
1450
1451 const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
1452 unsigned NumFileDecls = Record[7];
1453 if (NumFileDecls && ContextObj) {
1454 assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
1455 FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
1456 NumFileDecls));
1457 }
1458
1459 const SrcMgr::ContentCache *ContentCache
1460 = SourceMgr.getOrCreateContentCache(File, isSystem(FileCharacter));
1461 if (OverriddenBuffer && !ContentCache->BufferOverridden &&
1462 ContentCache->ContentsEntry == ContentCache->OrigEntry &&
1463 !ContentCache->getRawBuffer()) {
1464 auto Buffer = ReadBuffer(SLocEntryCursor, File->getName());
1465 if (!Buffer)
1466 return true;
1467 SourceMgr.overrideFileContents(File, std::move(Buffer));
1468 }
1469
1470 break;
1471 }
1472
1473 case SM_SLOC_BUFFER_ENTRY: {
1474 const char *Name = Blob.data();
1475 unsigned Offset = Record[0];
1476 SrcMgr::CharacteristicKind
1477 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1478 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1479 if (IncludeLoc.isInvalid() && F->isModule()) {
1480 IncludeLoc = getImportLocation(F);
1481 }
1482
1483 auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1484 if (!Buffer)
1485 return true;
1486 SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1487 BaseOffset + Offset, IncludeLoc);
1488 break;
1489 }
1490
1491 case SM_SLOC_EXPANSION_ENTRY: {
1492 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
1493 SourceMgr.createExpansionLoc(SpellingLoc,
1494 ReadSourceLocation(*F, Record[2]),
1495 ReadSourceLocation(*F, Record[3]),
1496 Record[5],
1497 Record[4],
1498 ID,
1499 BaseOffset + Record[0]);
1500 break;
1501 }
1502 }
1503
1504 return false;
1505}
1506
1507std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {
1508 if (ID == 0)
1509 return std::make_pair(SourceLocation(), "");
1510
1511 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1512 Error("source location entry ID out-of-range for AST file");
1513 return std::make_pair(SourceLocation(), "");
1514 }
1515
1516 // Find which module file this entry lands in.
1517 ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1518 if (!M->isModule())
1519 return std::make_pair(SourceLocation(), "");
1520
1521 // FIXME: Can we map this down to a particular submodule? That would be
1522 // ideal.
1523 return std::make_pair(M->ImportLoc, StringRef(M->ModuleName));
1524}
1525
1526/// Find the location where the module F is imported.
1527SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
1528 if (F->ImportLoc.isValid())
1529 return F->ImportLoc;
1530
1531 // Otherwise we have a PCH. It's considered to be "imported" at the first
1532 // location of its includer.
1533 if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
1534 // Main file is the importer.
1535 assert(SourceMgr.getMainFileID().isValid() && "missing main file");
1536 return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1537 }
1538 return F->ImportedBy[0]->FirstLoc;
1539}
1540
1541/// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1542/// specified cursor. Read the abbreviations that are at the top of the block
1543/// and then leave the cursor pointing into the block.
1544bool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID) {
1545 if (Cursor.EnterSubBlock(BlockID))
1546 return true;
1547
1548 while (true) {
1549 uint64_t Offset = Cursor.GetCurrentBitNo();
1550 unsigned Code = Cursor.ReadCode();
1551
1552 // We expect all abbrevs to be at the start of the block.
1553 if (Code != llvm::bitc::DEFINE_ABBREV) {
1554 Cursor.JumpToBit(Offset);
1555 return false;
1556 }
1557 Cursor.ReadAbbrevRecord();
1558 }
1559}
1560
1561Token ASTReader::ReadToken(ModuleFile &F, const RecordDataImpl &Record,
1562 unsigned &Idx) {
1563 Token Tok;
1564 Tok.startToken();
1565 Tok.setLocation(ReadSourceLocation(F, Record, Idx));
1566 Tok.setLength(Record[Idx++]);
1567 if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++]))
1568 Tok.setIdentifierInfo(II);
1569 Tok.setKind((tok::TokenKind)Record[Idx++]);
1570 Tok.setFlag((Token::TokenFlags)Record[Idx++]);
1571 return Tok;
1572}
1573
1574MacroInfo *ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset) {
1575 BitstreamCursor &Stream = F.MacroCursor;
1576
1577 // Keep track of where we are in the stream, then jump back there
1578 // after reading this macro.
1579 SavedStreamPosition SavedPosition(Stream);
1580
1581 Stream.JumpToBit(Offset);
1582 RecordData Record;
1583 SmallVector<IdentifierInfo*, 16> MacroParams;
1584 MacroInfo *Macro = nullptr;
1585
1586 while (true) {
1587 // Advance to the next record, but if we get to the end of the block, don't
1588 // pop it (removing all the abbreviations from the cursor) since we want to
1589 // be able to reseek within the block and read entries.
1590 unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1591 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(Flags);
1592
1593 switch (Entry.Kind) {
1594 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1595 case llvm::BitstreamEntry::Error:
1596 Error("malformed block record in AST file");
1597 return Macro;
1598 case llvm::BitstreamEntry::EndBlock:
1599 return Macro;
1600 case llvm::BitstreamEntry::Record:
1601 // The interesting case.
1602 break;
1603 }
1604
1605 // Read a record.
1606 Record.clear();
1607 PreprocessorRecordTypes RecType =
1608 (PreprocessorRecordTypes)Stream.readRecord(Entry.ID, Record);
1609 switch (RecType) {
1610 case PP_MODULE_MACRO:
1611 case PP_MACRO_DIRECTIVE_HISTORY:
1612 return Macro;
1613
1614 case PP_MACRO_OBJECT_LIKE:
1615 case PP_MACRO_FUNCTION_LIKE: {
1616 // If we already have a macro, that means that we've hit the end
1617 // of the definition of the macro we were looking for. We're
1618 // done.
1619 if (Macro)
1620 return Macro;
1621
1622 unsigned NextIndex = 1; // Skip identifier ID.
1623 SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
1624 MacroInfo *MI = PP.AllocateMacroInfo(Loc);
1625 MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
1626 MI->setIsUsed(Record[NextIndex++]);
1627 MI->setUsedForHeaderGuard(Record[NextIndex++]);
1628
1629 if (RecType == PP_MACRO_FUNCTION_LIKE) {
1630 // Decode function-like macro info.
1631 bool isC99VarArgs = Record[NextIndex++];
1632 bool isGNUVarArgs = Record[NextIndex++];
1633 bool hasCommaPasting = Record[NextIndex++];
1634 MacroParams.clear();
1635 unsigned NumArgs = Record[NextIndex++];
1636 for (unsigned i = 0; i != NumArgs; ++i)
1637 MacroParams.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1638
1639 // Install function-like macro info.
1640 MI->setIsFunctionLike();
1641 if (isC99VarArgs) MI->setIsC99Varargs();
1642 if (isGNUVarArgs) MI->setIsGNUVarargs();
1643 if (hasCommaPasting) MI->setHasCommaPasting();
1644 MI->setParameterList(MacroParams, PP.getPreprocessorAllocator());
1645 }
1646
1647 // Remember that we saw this macro last so that we add the tokens that
1648 // form its body to it.
1649 Macro = MI;
1650
1651 if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1652 Record[NextIndex]) {
1653 // We have a macro definition. Register the association
1654 PreprocessedEntityID
1655 GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1656 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
1657 PreprocessingRecord::PPEntityID PPID =
1658 PPRec.getPPEntityID(GlobalID - 1, /*isLoaded=*/true);
1659 MacroDefinitionRecord *PPDef = cast_or_null<MacroDefinitionRecord>(
1660 PPRec.getPreprocessedEntity(PPID));
1661 if (PPDef)
1662 PPRec.RegisterMacroDefinition(Macro, PPDef);
1663 }
1664
1665 ++NumMacrosRead;
1666 break;
1667 }
1668
1669 case PP_TOKEN: {
1670 // If we see a TOKEN before a PP_MACRO_*, then the file is
1671 // erroneous, just pretend we didn't see this.
1672 if (!Macro) break;
1673
1674 unsigned Idx = 0;
1675 Token Tok = ReadToken(F, Record, Idx);
1676 Macro->AddTokenToBody(Tok);
1677 break;
1678 }
1679 }
1680 }
1681}
1682
1683PreprocessedEntityID
1684ASTReader::getGlobalPreprocessedEntityID(ModuleFile &M,
1685 unsigned LocalID) const {
1686 if (!M.ModuleOffsetMap.empty())
1687 ReadModuleOffsetMap(M);
1688
1689 ContinuousRangeMap<uint32_t, int, 2>::const_iterator
1690 I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS);
1691 assert(I != M.PreprocessedEntityRemap.end()
1692 && "Invalid index into preprocessed entity index remap");
1693
1694 return LocalID + I->second;
1695}
1696
1697unsigned HeaderFileInfoTrait::ComputeHash(internal_key_ref ikey) {
1698 return llvm::hash_combine(ikey.Size, ikey.ModTime);
1699}
1700
1701HeaderFileInfoTrait::internal_key_type
1702HeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) {
1703 internal_key_type ikey = {FE->getSize(),
1704 M.HasTimestamps ? FE->getModificationTime() : 0,
1705 FE->getName(), /*Imported*/ false};
1706 return ikey;
1707}
1708
1709bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) {
1710 if (a.Size != b.Size || (a.ModTime && b.ModTime && a.ModTime != b.ModTime))
1711 return false;
1712
1713 if (llvm::sys::path::is_absolute(a.Filename) && a.Filename == b.Filename)
1714 return true;
1715
1716 // Determine whether the actual files are equivalent.
1717 FileManager &FileMgr = Reader.getFileManager();
1718 auto GetFile = [&](const internal_key_type &Key) -> const FileEntry* {
1719 if (!Key.Imported)
1720 return FileMgr.getFile(Key.Filename);
1721
1722 std::string Resolved = Key.Filename;
1723 Reader.ResolveImportedPath(M, Resolved);
1724 return FileMgr.getFile(Resolved);
1725 };
1726
1727 const FileEntry *FEA = GetFile(a);
1728 const FileEntry *FEB = GetFile(b);
1729 return FEA && FEA == FEB;
1730}
1731
1732std::pair<unsigned, unsigned>
1733HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
1734 using namespace llvm::support;
1735
1736 unsigned KeyLen = (unsigned) endian::readNext<uint16_t, little, unaligned>(d);
1737 unsigned DataLen = (unsigned) *d++;
1738 return std::make_pair(KeyLen, DataLen);
1739}
1740
1741HeaderFileInfoTrait::internal_key_type
1742HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
1743 using namespace llvm::support;
1744
1745 internal_key_type ikey;
1746 ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
1747 ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
1748 ikey.Filename = (const char *)d;
1749 ikey.Imported = true;
1750 return ikey;
1751}
1752
1753HeaderFileInfoTrait::data_type
1754HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
1755 unsigned DataLen) {
1756 using namespace llvm::support;
1757
1758 const unsigned char *End = d + DataLen;
1759 HeaderFileInfo HFI;
1760 unsigned Flags = *d++;
1761 // FIXME: Refactor with mergeHeaderFileInfo in HeaderSearch.cpp.
1762 HFI.isImport |= (Flags >> 5) & 0x01;
1763 HFI.isPragmaOnce |= (Flags >> 4) & 0x01;
1764 HFI.DirInfo = (Flags >> 1) & 0x07;
1765 HFI.IndexHeaderMapHeader = Flags & 0x01;
1766 // FIXME: Find a better way to handle this. Maybe just store a
1767 // "has been included" flag?
1768 HFI.NumIncludes = std::max(endian::readNext<uint16_t, little, unaligned>(d),
1769 HFI.NumIncludes);
1770 HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
1771 M, endian::readNext<uint32_t, little, unaligned>(d));
1772 if (unsigned FrameworkOffset =
1773 endian::readNext<uint32_t, little, unaligned>(d)) {
1774 // The framework offset is 1 greater than the actual offset,
1775 // since 0 is used as an indicator for "no framework name".
1776 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1777 HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1778 }
1779
1780 assert((End - d) % 4 == 0 &&
1781 "Wrong data length in HeaderFileInfo deserialization");
1782 while (d != End) {
1783 uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
1784 auto HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>(LocalSMID & 3);
1785 LocalSMID >>= 2;
1786
1787 // This header is part of a module. Associate it with the module to enable
1788 // implicit module import.
1789 SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
1790 Module *Mod = Reader.getSubmodule(GlobalSMID);
1791 FileManager &FileMgr = Reader.getFileManager();
1792 ModuleMap &ModMap =
1793 Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1794
1795 std::string Filename = key.Filename;
1796 if (key.Imported)
1797 Reader.ResolveImportedPath(M, Filename);
1798 // FIXME: This is not always the right filename-as-written, but we're not
1799 // going to use this information to rebuild the module, so it doesn't make
1800 // a lot of difference.
1801 Module::Header H = { key.Filename, FileMgr.getFile(Filename) };
1802 ModMap.addHeader(Mod, H, HeaderRole, /*Imported*/true);
1803 HFI.isModuleHeader |= !(HeaderRole & ModuleMap::TextualHeader);
1804 }
1805
1806 // This HeaderFileInfo was externally loaded.
1807 HFI.External = true;
1808 HFI.IsValid = true;
1809 return HFI;
1810}
1811
1812void ASTReader::addPendingMacro(IdentifierInfo *II,
1813 ModuleFile *M,
1814 uint64_t MacroDirectivesOffset) {
1815 assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
1816 PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
1817}
1818
1819void ASTReader::ReadDefinedMacros() {
1820 // Note that we are loading defined macros.
1821 Deserializing Macros(this);
1822
1823 for (ModuleFile &I : llvm::reverse(ModuleMgr)) {
1824 BitstreamCursor &MacroCursor = I.MacroCursor;
1825
1826 // If there was no preprocessor block, skip this file.
1827 if (MacroCursor.getBitcodeBytes().empty())
1828 continue;
1829
1830 BitstreamCursor Cursor = MacroCursor;
1831 Cursor.JumpToBit(I.MacroStartOffset);
1832
1833 RecordData Record;
1834 while (true) {
1835 llvm::BitstreamEntry E = Cursor.advanceSkippingSubblocks();
1836
1837 switch (E.Kind) {
1838 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1839 case llvm::BitstreamEntry::Error:
1840 Error("malformed block record in AST file");
1841 return;
1842 case llvm::BitstreamEntry::EndBlock:
1843 goto NextCursor;
1844
1845 case llvm::BitstreamEntry::Record:
1846 Record.clear();
1847 switch (Cursor.readRecord(E.ID, Record)) {
1848 default: // Default behavior: ignore.
1849 break;
1850
1851 case PP_MACRO_OBJECT_LIKE:
1852 case PP_MACRO_FUNCTION_LIKE: {
1853 IdentifierInfo *II = getLocalIdentifier(I, Record[0]);
1854 if (II->isOutOfDate())
1855 updateOutOfDateIdentifier(*II);
1856 break;
1857 }
1858
1859 case PP_TOKEN:
1860 // Ignore tokens.
1861 break;
1862 }
1863 break;
1864 }
1865 }
1866 NextCursor: ;
1867 }
1868}
1869
1870namespace {
1871
1872 /// Visitor class used to look up identifirs in an AST file.
1873 class IdentifierLookupVisitor {
1874 StringRef Name;
1875 unsigned NameHash;
1876 unsigned PriorGeneration;
1877 unsigned &NumIdentifierLookups;
1878 unsigned &NumIdentifierLookupHits;
1879 IdentifierInfo *Found = nullptr;
1880
1881 public:
1882 IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration,
1883 unsigned &NumIdentifierLookups,
1884 unsigned &NumIdentifierLookupHits)
1885 : Name(Name), NameHash(ASTIdentifierLookupTrait::ComputeHash(Name)),
1886 PriorGeneration(PriorGeneration),
1887 NumIdentifierLookups(NumIdentifierLookups),
1888 NumIdentifierLookupHits(NumIdentifierLookupHits) {}
1889
1890 bool operator()(ModuleFile &M) {
1891 // If we've already searched this module file, skip it now.
1892 if (M.Generation <= PriorGeneration)
1893 return true;
1894
1895 ASTIdentifierLookupTable *IdTable
1896 = (ASTIdentifierLookupTable *)M.IdentifierLookupTable;
1897 if (!IdTable)
1898 return false;
1899
1900 ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), M,
1901 Found);
1902 ++NumIdentifierLookups;
1903 ASTIdentifierLookupTable::iterator Pos =
1904 IdTable->find_hashed(Name, NameHash, &Trait);
1905 if (Pos == IdTable->end())
1906 return false;
1907
1908 // Dereferencing the iterator has the effect of building the
1909 // IdentifierInfo node and populating it with the various
1910 // declarations it needs.
1911 ++NumIdentifierLookupHits;
1912 Found = *Pos;
1913 return true;
1914 }
1915
1916 // Retrieve the identifier info found within the module
1917 // files.
1918 IdentifierInfo *getIdentifierInfo() const { return Found; }
1919 };
1920
1921} // namespace
1922
1923void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) {
1924 // Note that we are loading an identifier.
1925 Deserializing AnIdentifier(this);
1926
1927 unsigned PriorGeneration = 0;
1928 if (getContext().getLangOpts().Modules)
1929 PriorGeneration = IdentifierGeneration[&II];
1930
1931 // If there is a global index, look there first to determine which modules
1932 // provably do not have any results for this identifier.
1933 GlobalModuleIndex::HitSet Hits;
1934 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
1935 if (!loadGlobalIndex()) {
1936 if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {
1937 HitsPtr = &Hits;
1938 }
1939 }
1940
1941 IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration,
1942 NumIdentifierLookups,
1943 NumIdentifierLookupHits);
1944 ModuleMgr.visit(Visitor, HitsPtr);
1945 markIdentifierUpToDate(&II);
1946}
1947
1948void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) {
1949 if (!II)
1950 return;
1951
1952 II->setOutOfDate(false);
1953
1954 // Update the generation for this identifier.
1955 if (getContext().getLangOpts().Modules)
1956 IdentifierGeneration[II] = getGeneration();
1957}
1958
1959void ASTReader::resolvePendingMacro(IdentifierInfo *II,
1960 const PendingMacroInfo &PMInfo) {
1961 ModuleFile &M = *PMInfo.M;
1962
1963 BitstreamCursor &Cursor = M.MacroCursor;
1964 SavedStreamPosition SavedPosition(Cursor);
1965 Cursor.JumpToBit(PMInfo.MacroDirectivesOffset);
1966
1967 struct ModuleMacroRecord {
1968 SubmoduleID SubModID;
1969 MacroInfo *MI;
1970 SmallVector<SubmoduleID, 8> Overrides;
1971 };
1972 llvm::SmallVector<ModuleMacroRecord, 8> ModuleMacros;
1973
1974 // We expect to see a sequence of PP_MODULE_MACRO records listing exported
1975 // macros, followed by a PP_MACRO_DIRECTIVE_HISTORY record with the complete
1976 // macro histroy.
1977 RecordData Record;
1978 while (true) {
1979 llvm::BitstreamEntry Entry =
1980 Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
1981 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1982 Error("malformed block record in AST file");
1983 return;
1984 }
1985
1986 Record.clear();
1987 switch ((PreprocessorRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
1988 case PP_MACRO_DIRECTIVE_HISTORY:
1989 break;
1990
1991 case PP_MODULE_MACRO: {
1992 ModuleMacros.push_back(ModuleMacroRecord());
1993 auto &Info = ModuleMacros.back();
1994 Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
1995 Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
1996 for (int I = 2, N = Record.size(); I != N; ++I)
1997 Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
1998 continue;
1999 }
2000
2001 default:
2002 Error("malformed block record in AST file");
2003 return;
2004 }
2005
2006 // We found the macro directive history; that's the last record
2007 // for this macro.
2008 break;
2009 }
2010
2011 // Module macros are listed in reverse dependency order.
2012 {
2013 std::reverse(ModuleMacros.begin(), ModuleMacros.end());
2014 llvm::SmallVector<ModuleMacro*, 8> Overrides;
2015 for (auto &MMR : ModuleMacros) {
2016 Overrides.clear();
2017 for (unsigned ModID : MMR.Overrides) {
2018 Module *Mod = getSubmodule(ModID);
2019 auto *Macro = PP.getModuleMacro(Mod, II);
2020 assert(Macro && "missing definition for overridden macro");
2021 Overrides.push_back(Macro);
2022 }
2023
2024 bool Inserted = false;
2025 Module *Owner = getSubmodule(MMR.SubModID);
2026 PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
2027 }
2028 }
2029
2030 // Don't read the directive history for a module; we don't have anywhere
2031 // to put it.
2032 if (M.isModule())
2033 return;
2034
2035 // Deserialize the macro directives history in reverse source-order.
2036 MacroDirective *Latest = nullptr, *Earliest = nullptr;
2037 unsigned Idx = 0, N = Record.size();
2038 while (Idx < N) {
2039 MacroDirective *MD = nullptr;
2040 SourceLocation Loc = ReadSourceLocation(M, Record, Idx);
2041 MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++];
2042 switch (K) {
2043 case MacroDirective::MD_Define: {
2044 MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
2045 MD = PP.AllocateDefMacroDirective(MI, Loc);
2046 break;
2047 }
2048 case MacroDirective::MD_Undefine:
2049 MD = PP.AllocateUndefMacroDirective(Loc);
2050 break;
2051 case MacroDirective::MD_Visibility:
2052 bool isPublic = Record[Idx++];
2053 MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
2054 break;
2055 }
2056
2057 if (!Latest)
2058 Latest = MD;
2059 if (Earliest)
2060 Earliest->setPrevious(MD);
2061 Earliest = MD;
2062 }
2063
2064 if (Latest)
2065 PP.setLoadedMacroDirective(II, Earliest, Latest);
2066}
2067
2068ASTReader::InputFileInfo
2069ASTReader::readInputFileInfo(ModuleFile &F, unsigned ID) {
2070 // Go find this input file.
2071 BitstreamCursor &Cursor = F.InputFilesCursor;
2072 SavedStreamPosition SavedPosition(Cursor);
2073 Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
2074
2075 unsigned Code = Cursor.ReadCode();
2076 RecordData Record;
2077 StringRef Blob;
2078
2079 unsigned Result = Cursor.readRecord(Code, Record, &Blob);
2080 assert(static_cast<InputFileRecordTypes>(Result) == INPUT_FILE &&
2081 "invalid record type for input file");
2082 (void)Result;
2083
2084 assert(Record[0] == ID && "Bogus stored ID or offset");
2085 InputFileInfo R;
2086 R.StoredSize = static_cast<off_t>(Record[1]);
2087 R.StoredTime = static_cast<time_t>(Record[2]);
2088 R.Overridden = static_cast<bool>(Record[3]);
2089 R.Transient = static_cast<bool>(Record[4]);
2090 R.TopLevelModuleMap = static_cast<bool>(Record[5]);
2091 R.Filename = Blob;
2092 ResolveImportedPath(F, R.Filename);
2093 return R;
2094}
2095
2096static unsigned moduleKindForDiagnostic(ModuleKind Kind);
2097InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
2098 // If this ID is bogus, just return an empty input file.
2099 if (ID == 0 || ID > F.InputFilesLoaded.size())
2100 return InputFile();
2101
2102 // If we've already loaded this input file, return it.
2103 if (F.InputFilesLoaded[ID-1].getFile())
2104 return F.InputFilesLoaded[ID-1];
2105
2106 if (F.InputFilesLoaded[ID-1].isNotFound())
2107 return InputFile();
2108
2109 // Go find this input file.
2110 BitstreamCursor &Cursor = F.InputFilesCursor;
2111 SavedStreamPosition SavedPosition(Cursor);
2112 Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
2113
2114 InputFileInfo FI = readInputFileInfo(F, ID);
2115 off_t StoredSize = FI.StoredSize;
2116 time_t StoredTime = FI.StoredTime;
2117 bool Overridden = FI.Overridden;
2118 bool Transient = FI.Transient;
2119 StringRef Filename = FI.Filename;
2120
2121 const FileEntry *File = FileMgr.getFile(Filename, /*OpenFile=*/false);
2122 // If we didn't find the file, resolve it relative to the
2123 // original directory from which this AST file was created.
2124 if (File == nullptr && !F.OriginalDir.empty() && !F.BaseDirectory.empty() &&
2125 F.OriginalDir != F.BaseDirectory) {
2126 std::string Resolved = resolveFileRelativeToOriginalDir(
2127 Filename, F.OriginalDir, F.BaseDirectory);
2128 if (!Resolved.empty())
2129 File = FileMgr.getFile(Resolved);
2130 }
2131
2132 // For an overridden file, create a virtual file with the stored
2133 // size/timestamp.
2134 if ((Overridden || Transient) && File == nullptr)
2135 File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime);
2136
2137 if (File == nullptr) {
2138 if (Complain) {
2139 std::string ErrorStr = "could not find file '";
2140 ErrorStr += Filename;
2141 ErrorStr += "' referenced by AST file '";
2142 ErrorStr += F.FileName;
2143 ErrorStr += "'";
2144 Error(ErrorStr);
2145 }
2146 // Record that we didn't find the file.
2147 F.InputFilesLoaded[ID-1] = InputFile::getNotFound();
2148 return InputFile();
2149 }
2150
2151 // Check if there was a request to override the contents of the file
2152 // that was part of the precompiled header. Overriding such a file
2153 // can lead to problems when lexing using the source locations from the
2154 // PCH.
2155 SourceManager &SM = getSourceManager();
2156 // FIXME: Reject if the overrides are different.
2157 if ((!Overridden && !Transient) && SM.isFileOverridden(File)) {
2158 if (Complain)
2159 Error(diag::err_fe_pch_file_overridden, Filename);
2160 // After emitting the diagnostic, recover by disabling the override so
2161 // that the original file will be used.
2162 //
2163 // FIXME: This recovery is just as broken as the original state; there may
2164 // be another precompiled module that's using the overridden contents, or
2165 // we might be half way through parsing it. Instead, we should treat the
2166 // overridden contents as belonging to a separate FileEntry.
2167 SM.disableFileContentsOverride(File);
2168 // The FileEntry is a virtual file entry with the size of the contents
2169 // that would override the original contents. Set it to the original's
2170 // size/time.
2171 FileMgr.modifyFileEntry(const_cast<FileEntry*>(File),
2172 StoredSize, StoredTime);
2173 }
2174
2175 bool IsOutOfDate = false;
2176
2177 // For an overridden file, there is nothing to validate.
2178 if (!Overridden && //
2179 (StoredSize != File->getSize() ||
2180 (StoredTime && StoredTime != File->getModificationTime() &&
2181 !DisableValidation)
2182 )) {
2183 if (Complain) {
2184 // Build a list of the PCH imports that got us here (in reverse).
2185 SmallVector<ModuleFile *, 4> ImportStack(1, &F);
2186 while (!ImportStack.back()->ImportedBy.empty())
2187 ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2188
2189 // The top-level PCH is stale.
2190 StringRef TopLevelPCHName(ImportStack.back()->FileName);
2191 unsigned DiagnosticKind = moduleKindForDiagnostic(ImportStack.back()->Kind);
2192 if (DiagnosticKind == 0)
2193 Error(diag::err_fe_pch_file_modified, Filename, TopLevelPCHName);
2194 else if (DiagnosticKind == 1)
2195 Error(diag::err_fe_module_file_modified, Filename, TopLevelPCHName);
2196 else
2197 Error(diag::err_fe_ast_file_modified, Filename, TopLevelPCHName);
2198
2199 // Print the import stack.
2200 if (ImportStack.size() > 1 && !Diags.isDiagnosticInFlight()) {
2201 Diag(diag::note_pch_required_by)
2202 << Filename << ImportStack[0]->FileName;
2203 for (unsigned I = 1; I < ImportStack.size(); ++I)
2204 Diag(diag::note_pch_required_by)
2205 << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2206 }
2207
2208 if (!Diags.isDiagnosticInFlight())
2209 Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2210 }
2211
2212 IsOutOfDate = true;
2213 }
2214 // FIXME: If the file is overridden and we've already opened it,
2215 // issue an error (or split it into a separate FileEntry).
2216
2217 InputFile IF = InputFile(File, Overridden || Transient, IsOutOfDate);
2218
2219 // Note that we've loaded this input file.
2220 F.InputFilesLoaded[ID-1] = IF;
2221 return IF;
2222}
2223
2224/// If we are loading a relocatable PCH or module file, and the filename
2225/// is not an absolute path, add the system or module root to the beginning of
2226/// the file name.
2227void ASTReader::ResolveImportedPath(ModuleFile &M, std::string &Filename) {
2228 // Resolve relative to the base directory, if we have one.
2229 if (!M.BaseDirectory.empty())
2230 return ResolveImportedPath(Filename, M.BaseDirectory);
2231}
2232
2233void ASTReader::ResolveImportedPath(std::string &Filename, StringRef Prefix) {
2234 if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
2235 return;
2236
2237 SmallString<128> Buffer;
2238 llvm::sys::path::append(Buffer, Prefix, Filename);
2239 Filename.assign(Buffer.begin(), Buffer.end());
2240}
2241
2242static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps) {
2243 switch (ARR) {
2244 case ASTReader::Failure: return true;
2245 case ASTReader::Missing: return !(Caps & ASTReader::ARR_Missing);
2246 case ASTReader::OutOfDate: return !(Caps & ASTReader::ARR_OutOfDate);
2247 case ASTReader::VersionMismatch: return !(Caps & ASTReader::ARR_VersionMismatch);
2248 case ASTReader::ConfigurationMismatch:
2249 return !(Caps & ASTReader::ARR_ConfigurationMismatch);
2250 case ASTReader::HadErrors: return true;
2251 case ASTReader::Success: return false;
2252 }
2253
2254 llvm_unreachable("unknown ASTReadResult");
2255}
2256
2257ASTReader::ASTReadResult ASTReader::ReadOptionsBlock(
2258 BitstreamCursor &Stream, unsigned ClientLoadCapabilities,
2259 bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener,
2260 std::string &SuggestedPredefines) {
2261 if (Stream.EnterSubBlock(OPTIONS_BLOCK_ID))
2262 return Failure;
2263
2264 // Read all of the records in the options block.
2265 RecordData Record;
2266 ASTReadResult Result = Success;
2267 while (true) {
2268 llvm::BitstreamEntry Entry = Stream.advance();
2269
2270 switch (Entry.Kind) {
2271 case llvm::BitstreamEntry::Error:
2272 case llvm::BitstreamEntry::SubBlock:
2273 return Failure;
2274
2275 case llvm::BitstreamEntry::EndBlock:
2276 return Result;
2277
2278 case llvm::BitstreamEntry::Record:
2279 // The interesting case.
2280 break;
2281 }
2282
2283 // Read and process a record.
2284 Record.clear();
2285 switch ((OptionsRecordTypes)Stream.readRecord(Entry.ID, Record)) {
2286 case LANGUAGE_OPTIONS: {
2287 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2288 if (ParseLanguageOptions(Record, Complain, Listener,
2289 AllowCompatibleConfigurationMismatch))
2290 Result = ConfigurationMismatch;
2291 break;
2292 }
2293
2294 case TARGET_OPTIONS: {
2295 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2296 if (ParseTargetOptions(Record, Complain, Listener,
2297 AllowCompatibleConfigurationMismatch))
2298 Result = ConfigurationMismatch;
2299 break;
2300 }
2301
2302 case FILE_SYSTEM_OPTIONS: {
2303 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2304 if (!AllowCompatibleConfigurationMismatch &&
2305 ParseFileSystemOptions(Record, Complain, Listener))
2306 Result = ConfigurationMismatch;
2307 break;
2308 }
2309
2310 case HEADER_SEARCH_OPTIONS: {
2311 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2312 if (!AllowCompatibleConfigurationMismatch &&
2313 ParseHeaderSearchOptions(Record, Complain, Listener))
2314 Result = ConfigurationMismatch;
2315 break;
2316 }
2317
2318 case PREPROCESSOR_OPTIONS:
2319 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2320 if (!AllowCompatibleConfigurationMismatch &&
2321 ParsePreprocessorOptions(Record, Complain, Listener,
2322 SuggestedPredefines))
2323 Result = ConfigurationMismatch;
2324 break;
2325 }
2326 }
2327}
2328
2329ASTReader::ASTReadResult
2330ASTReader::ReadControlBlock(ModuleFile &F,
2331 SmallVectorImpl<ImportedModule> &Loaded,
2332 const ModuleFile *ImportedBy,
2333 unsigned ClientLoadCapabilities) {
2334 BitstreamCursor &Stream = F.Stream;
2335 ASTReadResult Result = Success;
2336
2337 if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
2338 Error("malformed block record in AST file");
2339 return Failure;
2340 }
2341
2342 // Lambda to read the unhashed control block the first time it's called.
2343 //
2344 // For PCM files, the unhashed control block cannot be read until after the
2345 // MODULE_NAME record. However, PCH files have no MODULE_NAME, and yet still
2346 // need to look ahead before reading the IMPORTS record. For consistency,
2347 // this block is always read somehow (see BitstreamEntry::EndBlock).
2348 bool HasReadUnhashedControlBlock = false;
2349 auto readUnhashedControlBlockOnce = [&]() {
2350 if (!HasReadUnhashedControlBlock) {
2351 HasReadUnhashedControlBlock = true;
2352 if (ASTReadResult Result =
2353 readUnhashedControlBlock(F, ImportedBy, ClientLoadCapabilities))
2354 return Result;
2355 }
2356 return Success;
2357 };
2358
2359 // Read all of the records and blocks in the control block.
2360 RecordData Record;
2361 unsigned NumInputs = 0;
2362 unsigned NumUserInputs = 0;
2363 StringRef BaseDirectoryAsWritten;
2364 while (true) {
2365 llvm::BitstreamEntry Entry = Stream.advance();
2366
2367 switch (Entry.Kind) {
2368 case llvm::BitstreamEntry::Error:
2369 Error("malformed block record in AST file");
2370 return Failure;
2371 case llvm::BitstreamEntry::EndBlock: {
2372 // Validate the module before returning. This call catches an AST with
2373 // no module name and no imports.
2374 if (ASTReadResult Result = readUnhashedControlBlockOnce())
2375 return Result;
2376
2377 // Validate input files.
2378 const HeaderSearchOptions &HSOpts =
2379 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2380
2381 // All user input files reside at the index range [0, NumUserInputs), and
2382 // system input files reside at [NumUserInputs, NumInputs). For explicitly
2383 // loaded module files, ignore missing inputs.
2384 if (!DisableValidation && F.Kind != MK_ExplicitModule &&
2385 F.Kind != MK_PrebuiltModule) {
2386 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2387
2388 // If we are reading a module, we will create a verification timestamp,
2389 // so we verify all input files. Otherwise, verify only user input
2390 // files.
2391
2392 unsigned N = NumUserInputs;
2393 if (ValidateSystemInputs ||
2394 (HSOpts.ModulesValidateOncePerBuildSession &&
2395 F.InputFilesValidationTimestamp <= HSOpts.BuildSessionTimestamp &&
2396 F.Kind == MK_ImplicitModule))
2397 N = NumInputs;
2398
2399 for (unsigned I = 0; I < N; ++I) {
2400 InputFile IF = getInputFile(F, I+1, Complain);
2401 if (!IF.getFile() || IF.isOutOfDate())
2402 return OutOfDate;
2403 }
2404 }
2405
2406 if (Listener)
2407 Listener->visitModuleFile(F.FileName, F.Kind);
2408
2409 if (Listener && Listener->needsInputFileVisitation()) {
2410 unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs
2411 : NumUserInputs;
2412 for (unsigned I = 0; I < N; ++I) {
2413 bool IsSystem = I >= NumUserInputs;
2414 InputFileInfo FI = readInputFileInfo(F, I+1);
2415 Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden,
2416 F.Kind == MK_ExplicitModule ||
2417 F.Kind == MK_PrebuiltModule);
2418 }
2419 }
2420
2421 return Result;
2422 }
2423
2424 case llvm::BitstreamEntry::SubBlock:
2425 switch (Entry.ID) {
2426 case INPUT_FILES_BLOCK_ID:
2427 F.InputFilesCursor = Stream;
2428 if (Stream.SkipBlock() || // Skip with the main cursor
2429 // Read the abbreviations
2430 ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
2431 Error("malformed block record in AST file");
2432 return Failure;
2433 }
2434 continue;
2435
2436 case OPTIONS_BLOCK_ID:
2437 // If we're reading the first module for this group, check its options
2438 // are compatible with ours. For modules it imports, no further checking
2439 // is required, because we checked them when we built it.
2440 if (Listener && !ImportedBy) {
2441 // Should we allow the configuration of the module file to differ from
2442 // the configuration of the current translation unit in a compatible
2443 // way?
2444 //
2445 // FIXME: Allow this for files explicitly specified with -include-pch.
2446 bool AllowCompatibleConfigurationMismatch =
2447 F.Kind == MK_ExplicitModule || F.Kind == MK_PrebuiltModule;
2448
2449 Result = ReadOptionsBlock(Stream, ClientLoadCapabilities,
2450 AllowCompatibleConfigurationMismatch,
2451 *Listener, SuggestedPredefines);
2452 if (Result == Failure) {
2453 Error("malformed block record in AST file");
2454 return Result;
2455 }
2456
2457 if (DisableValidation ||
2458 (AllowConfigurationMismatch && Result == ConfigurationMismatch))
2459 Result = Success;
2460
2461 // If we can't load the module, exit early since we likely
2462 // will rebuild the module anyway. The stream may be in the
2463 // middle of a block.
2464 if (Result != Success)
2465 return Result;
2466 } else if (Stream.SkipBlock()) {
2467 Error("malformed block record in AST file");
2468 return Failure;
2469 }
2470 continue;
2471
2472 default:
2473 if (Stream.SkipBlock()) {
2474 Error("malformed block record in AST file");
2475 return Failure;
2476 }
2477 continue;
2478 }
2479
2480 case llvm::BitstreamEntry::Record:
2481 // The interesting case.
2482 break;
2483 }
2484
2485 // Read and process a record.
2486 Record.clear();
2487 StringRef Blob;
2488 switch ((ControlRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
2489 case METADATA: {
2490 if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2491 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2492 Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old
2493 : diag::err_pch_version_too_new);
2494 return VersionMismatch;
2495 }
2496
2497 bool hasErrors = Record[7];
2498 if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) {
2499 Diag(diag::err_pch_with_compiler_errors);
2500 return HadErrors;
2501 }
2502 if (hasErrors) {
2503 Diags.ErrorOccurred = true;
2504 Diags.UncompilableErrorOccurred = true;
2505 Diags.UnrecoverableErrorOccurred = true;
2506 }
2507
2508 F.RelocatablePCH = Record[4];
2509 // Relative paths in a relocatable PCH are relative to our sysroot.
2510 if (F.RelocatablePCH)
2511 F.BaseDirectory = isysroot.empty() ? "/" : isysroot;
2512
2513 F.HasTimestamps = Record[5];
2514
2515 F.PCHHasObjectFile = Record[6];
2516
2517 const std::string &CurBranch = getClangFullRepositoryVersion();
2518 StringRef ASTBranch = Blob;
2519 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2520 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2521 Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
2522 return VersionMismatch;
2523 }
2524 break;
2525 }
2526
2527 case IMPORTS: {
2528 // Validate the AST before processing any imports (otherwise, untangling
2529 // them can be error-prone and expensive). A module will have a name and
2530 // will already have been validated, but this catches the PCH case.
2531 if (ASTReadResult Result = readUnhashedControlBlockOnce())
2532 return Result;
2533
2534 // Load each of the imported PCH files.
2535 unsigned Idx = 0, N = Record.size();
2536 while (Idx < N) {
2537 // Read information about the AST file.
2538 ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
2539 // The import location will be the local one for now; we will adjust
2540 // all import locations of module imports after the global source
2541 // location info are setup, in ReadAST.
2542 SourceLocation ImportLoc =
2543 ReadUntranslatedSourceLocation(Record[Idx++]);
2544 off_t StoredSize = (off_t)Record[Idx++];
2545 time_t StoredModTime = (time_t)Record[Idx++];
2546 ASTFileSignature StoredSignature = {
2547 {{(uint32_t)Record[Idx++], (uint32_t)Record[Idx++],
2548 (uint32_t)Record[Idx++], (uint32_t)Record[Idx++],
2549 (uint32_t)Record[Idx++]}}};
2550
2551 std::string ImportedName = ReadString(Record, Idx);
2552 std::string ImportedFile;
2553
2554 // For prebuilt and explicit modules first consult the file map for
2555 // an override. Note that here we don't search prebuilt module
2556 // directories, only the explicit name to file mappings. Also, we will
2557 // still verify the size/signature making sure it is essentially the
2558 // same file but perhaps in a different location.
2559 if (ImportedKind == MK_PrebuiltModule || ImportedKind == MK_ExplicitModule)
2560 ImportedFile = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(
2561 ImportedName, /*FileMapOnly*/ true);
2562
2563 if (ImportedFile.empty())
2564 // Use BaseDirectoryAsWritten to ensure we use the same path in the
2565 // ModuleCache as when writing.
2566 ImportedFile = ReadPath(BaseDirectoryAsWritten, Record, Idx);
2567 else
2568 SkipPath(Record, Idx);
2569
2570 // If our client can't cope with us being out of date, we can't cope with
2571 // our dependency being missing.
2572 unsigned Capabilities = ClientLoadCapabilities;
2573 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2574 Capabilities &= ~ARR_Missing;
2575
2576 // Load the AST file.
2577 auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
2578 Loaded, StoredSize, StoredModTime,
2579 StoredSignature, Capabilities);
2580
2581 // If we diagnosed a problem, produce a backtrace.
2582 if (isDiagnosedResult(Result, Capabilities))
2583 Diag(diag::note_module_file_imported_by)
2584 << F.FileName << !F.ModuleName.empty() << F.ModuleName;
2585
2586 switch (Result) {
2587 case Failure: return Failure;
2588 // If we have to ignore the dependency, we'll have to ignore this too.
2589 case Missing:
2590 case OutOfDate: return OutOfDate;
2591 case VersionMismatch: return VersionMismatch;
2592 case ConfigurationMismatch: return ConfigurationMismatch;
2593 case HadErrors: return HadErrors;
2594 case Success: break;
2595 }
2596 }
2597 break;
2598 }
2599
2600 case ORIGINAL_FILE:
2601 F.OriginalSourceFileID = FileID::get(Record[0]);
2602 F.ActualOriginalSourceFileName = Blob;
2603 F.OriginalSourceFileName = F.ActualOriginalSourceFileName;
2604 ResolveImportedPath(F, F.OriginalSourceFileName);
2605 break;
2606
2607 case ORIGINAL_FILE_ID:
2608 F.OriginalSourceFileID = FileID::get(Record[0]);
2609 break;
2610
2611 case ORIGINAL_PCH_DIR:
2612 F.OriginalDir = Blob;
2613 break;
2614
2615 case MODULE_NAME:
2616 F.ModuleName = Blob;
2617 Diag(diag::remark_module_import)
2618 << F.ModuleName << F.FileName << (ImportedBy ? true : false)
2619 << (ImportedBy ? StringRef(ImportedBy->ModuleName) : StringRef());
2620 if (Listener)
2621 Listener->ReadModuleName(F.ModuleName);
2622
2623 // Validate the AST as soon as we have a name so we can exit early on
2624 // failure.
2625 if (ASTReadResult Result = readUnhashedControlBlockOnce())
2626 return Result;
2627
2628 break;
2629
2630 case MODULE_DIRECTORY: {
2631 // Save the BaseDirectory as written in the PCM for computing the module
2632 // filename for the ModuleCache.
2633 BaseDirectoryAsWritten = Blob;
2634 assert(!F.ModuleName.empty() &&
2635 "MODULE_DIRECTORY found before MODULE_NAME");
2636 // If we've already loaded a module map file covering this module, we may
2637 // have a better path for it (relative to the current build).
2638 Module *M = PP.getHeaderSearchInfo().lookupModule(
2639 F.ModuleName, /*AllowSearch*/ true,
2640 /*AllowExtraModuleMapSearch*/ true);
2641 if (M && M->Directory) {
2642 // If we're implicitly loading a module, the base directory can't
2643 // change between the build and use.
2644 // Don't emit module relocation error if we have -fno-validate-pch
2645 if (!PP.getPreprocessorOpts().DisablePCHValidation &&
2646 F.Kind != MK_ExplicitModule && F.Kind != MK_PrebuiltModule) {
2647 const DirectoryEntry *BuildDir =
2648 PP.getFileManager().getDirectory(Blob);
2649 if (!BuildDir || BuildDir != M->Directory) {
2650 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2651 Diag(diag::err_imported_module_relocated)
2652 << F.ModuleName << Blob << M->Directory->getName();
2653 return OutOfDate;
2654 }
2655 }
2656 F.BaseDirectory = M->Directory->getName();
2657 } else {
2658 F.BaseDirectory = Blob;
2659 }
2660 break;
2661 }
2662
2663 case MODULE_MAP_FILE:
2664 if (ASTReadResult Result =
2665 ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
2666 return Result;
2667 break;
2668
2669 case INPUT_FILE_OFFSETS:
2670 NumInputs = Record[0];
2671 NumUserInputs = Record[1];
2672 F.InputFileOffsets =
2673 (const llvm::support::unaligned_uint64_t *)Blob.data();
2674 F.InputFilesLoaded.resize(NumInputs);
2675 F.NumUserInputFiles = NumUserInputs;
2676 break;
2677 }
2678 }
2679}
2680
2681ASTReader::ASTReadResult
2682ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
2683 BitstreamCursor &Stream = F.Stream;
2684
2685 if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
2686 Error("malformed block record in AST file");
2687 return Failure;
2688 }
2689
2690 // Read all of the records and blocks for the AST file.
2691 RecordData Record;
2692 while (true) {
2693 llvm::BitstreamEntry Entry = Stream.advance();
2694
2695 switch (Entry.Kind) {
2696 case llvm::BitstreamEntry::Error:
2697 Error("error at end of module block in AST file");
2698 return Failure;
2699 case llvm::BitstreamEntry::EndBlock:
2700 // Outside of C++, we do not store a lookup map for the translation unit.
2701 // Instead, mark it as needing a lookup map to be built if this module
2702 // contains any declarations lexically within it (which it always does!).
2703 // This usually has no cost, since we very rarely need the lookup map for
2704 // the translation unit outside C++.
2705 if (ASTContext *Ctx = ContextObj) {
2706 DeclContext *DC = Ctx->getTranslationUnitDecl();
2707 if (DC->hasExternalLexicalStorage() && !Ctx->getLangOpts().CPlusPlus)
2708 DC->setMustBuildLookupTable();
2709 }
2710
2711 return Success;
2712 case llvm::BitstreamEntry::SubBlock:
2713 switch (Entry.ID) {
2714 case DECLTYPES_BLOCK_ID:
2715 // We lazily load the decls block, but we want to set up the
2716 // DeclsCursor cursor to point into it. Clone our current bitcode
2717 // cursor to it, enter the block and read the abbrevs in that block.
2718 // With the main cursor, we just skip over it.
2719 F.DeclsCursor = Stream;
2720 if (Stream.SkipBlock() || // Skip with the main cursor.
2721 // Read the abbrevs.
2722 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
2723 Error("malformed block record in AST file");
2724 return Failure;
2725 }
2726 break;
2727
2728 case PREPROCESSOR_BLOCK_ID:
2729 F.MacroCursor = Stream;
2730 if (!PP.getExternalSource())
2731 PP.setExternalSource(this);
2732
2733 if (Stream.SkipBlock() ||
2734 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
2735 Error("malformed block record in AST file");
2736 return Failure;
2737 }
2738 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
2739 break;
2740
2741 case PREPROCESSOR_DETAIL_BLOCK_ID:
2742 F.PreprocessorDetailCursor = Stream;
2743 if (Stream.SkipBlock() ||
2744 ReadBlockAbbrevs(F.PreprocessorDetailCursor,
2745 PREPROCESSOR_DETAIL_BLOCK_ID)) {
2746 Error("malformed preprocessor detail record in AST file");
2747 return Failure;
2748 }
2749 F.PreprocessorDetailStartOffset
2750 = F.PreprocessorDetailCursor.GetCurrentBitNo();
2751
2752 if (!PP.getPreprocessingRecord())
2753 PP.createPreprocessingRecord();
2754 if (!PP.getPreprocessingRecord()->getExternalSource())
2755 PP.getPreprocessingRecord()->SetExternalSource(*this);
2756 break;
2757
2758 case SOURCE_MANAGER_BLOCK_ID:
2759 if (ReadSourceManagerBlock(F))
2760 return Failure;
2761 break;
2762
2763 case SUBMODULE_BLOCK_ID:
2764 if (ASTReadResult Result =
2765 ReadSubmoduleBlock(F, ClientLoadCapabilities))
2766 return Result;
2767 break;
2768
2769 case COMMENTS_BLOCK_ID: {
2770 BitstreamCursor C = Stream;
2771 if (Stream.SkipBlock() ||
2772 ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) {
2773 Error("malformed comments block in AST file");
2774 return Failure;
2775 }
2776 CommentsCursors.push_back(std::make_pair(C, &F));
2777 break;
2778 }
2779
2780 default:
2781 if (Stream.SkipBlock()) {
2782 Error("malformed block record in AST file");
2783 return Failure;
2784 }
2785 break;
2786 }
2787 continue;
2788
2789 case llvm::BitstreamEntry::Record:
2790 // The interesting case.
2791 break;
2792 }
2793
2794 // Read and process a record.
2795 Record.clear();
2796 StringRef Blob;
2797 auto RecordType =
2798 (ASTRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob);
2799
2800 // If we're not loading an AST context, we don't care about most records.
2801 if (!ContextObj) {
2802 switch (RecordType) {
2803 case IDENTIFIER_TABLE:
2804 case IDENTIFIER_OFFSET:
2805 case INTERESTING_IDENTIFIERS:
2806 case STATISTICS:
2807 case PP_CONDITIONAL_STACK:
2808 case PP_COUNTER_VALUE:
2809 case SOURCE_LOCATION_OFFSETS:
2810 case MODULE_OFFSET_MAP:
2811 case SOURCE_MANAGER_LINE_TABLE:
2812 case SOURCE_LOCATION_PRELOADS:
2813 case PPD_ENTITIES_OFFSETS:
2814 case HEADER_SEARCH_TABLE:
2815 case IMPORTED_MODULES:
2816 case MACRO_OFFSET:
2817 break;
2818 default:
2819 continue;
2820 }
2821 }
2822
2823 switch (RecordType) {
2824 default: // Default behavior: ignore.
2825 break;
2826
2827 case TYPE_OFFSET: {
2828 if (F.LocalNumTypes != 0) {
2829 Error("duplicate TYPE_OFFSET record in AST file");
2830 return Failure;
2831 }
2832 F.TypeOffsets = (const uint32_t *)Blob.data();
2833 F.LocalNumTypes = Record[0];
2834 unsigned LocalBaseTypeIndex = Record[1];
2835 F.BaseTypeIndex = getTotalNumTypes();
2836
2837 if (F.LocalNumTypes > 0) {
2838 // Introduce the global -> local mapping for types within this module.
2839 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
2840
2841 // Introduce the local -> global mapping for types within this module.
2842 F.TypeRemap.insertOrReplace(
2843 std::make_pair(LocalBaseTypeIndex,
2844 F.BaseTypeIndex - LocalBaseTypeIndex));
2845
2846 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
2847 }
2848 break;
2849 }
2850
2851 case DECL_OFFSET: {
2852 if (F.LocalNumDecls != 0) {
2853 Error("duplicate DECL_OFFSET record in AST file");
2854 return Failure;
2855 }
2856 F.DeclOffsets = (const DeclOffset *)Blob.data();
2857 F.LocalNumDecls = Record[0];
2858 unsigned LocalBaseDeclID = Record[1];
2859 F.BaseDeclID = getTotalNumDecls();
2860
2861 if (F.LocalNumDecls > 0) {
2862 // Introduce the global -> local mapping for declarations within this
2863 // module.
2864 GlobalDeclMap.insert(
2865 std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
2866
2867 // Introduce the local -> global mapping for declarations within this
2868 // module.
2869 F.DeclRemap.insertOrReplace(
2870 std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
2871
2872 // Introduce the global -> local mapping for declarations within this
2873 // module.
2874 F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
2875
2876 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
2877 }
2878 break;
2879 }
2880
2881 case TU_UPDATE_LEXICAL: {
2882 DeclContext *TU = ContextObj->getTranslationUnitDecl();
2883 LexicalContents Contents(
2884 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
2885 Blob.data()),
2886 static_cast<unsigned int>(Blob.size() / 4));
2887 TULexicalDecls.push_back(std::make_pair(&F, Contents));
2888 TU->setHasExternalLexicalStorage(true);
2889 break;
2890 }
2891
2892 case UPDATE_VISIBLE: {
2893 unsigned Idx = 0;
2894 serialization::DeclID ID = ReadDeclID(F, Record, Idx);
2895 auto *Data = (const unsigned char*)Blob.data();
2896 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&F, Data});
2897 // If we've already loaded the decl, perform the updates when we finish
2898 // loading this block.
2899 if (Decl *D = GetExistingDecl(ID))
2900 PendingUpdateRecords.push_back(
2901 PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
2902 break;
2903 }
2904
2905 case IDENTIFIER_TABLE:
2906 F.IdentifierTableData = Blob.data();
2907 if (Record[0]) {
2908 F.IdentifierLookupTable = ASTIdentifierLookupTable::Create(
2909 (const unsigned char *)F.IdentifierTableData + Record[0],
2910 (const unsigned char *)F.IdentifierTableData + sizeof(uint32_t),
2911 (const unsigned char *)F.IdentifierTableData,
2912 ASTIdentifierLookupTrait(*this, F));
2913
2914 PP.getIdentifierTable().setExternalIdentifierLookup(this);
2915 }
2916 break;
2917
2918 case IDENTIFIER_OFFSET: {
2919 if (F.LocalNumIdentifiers != 0) {
2920 Error("duplicate IDENTIFIER_OFFSET record in AST file");
2921 return Failure;
2922 }
2923 F.IdentifierOffsets = (const uint32_t *)Blob.data();
2924 F.LocalNumIdentifiers = Record[0];
2925 unsigned LocalBaseIdentifierID = Record[1];
2926 F.BaseIdentifierID = getTotalNumIdentifiers();
2927
2928 if (F.LocalNumIdentifiers > 0) {
2929 // Introduce the global -> local mapping for identifiers within this
2930 // module.
2931 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
2932 &F));
2933
2934 // Introduce the local -> global mapping for identifiers within this
2935 // module.
2936 F.IdentifierRemap.insertOrReplace(
2937 std::make_pair(LocalBaseIdentifierID,
2938 F.BaseIdentifierID - LocalBaseIdentifierID));
2939
2940 IdentifiersLoaded.resize(IdentifiersLoaded.size()
2941 + F.LocalNumIdentifiers);
2942 }
2943 break;
2944 }
2945
2946 case INTERESTING_IDENTIFIERS:
2947 F.PreloadIdentifierOffsets.assign(Record.begin(), Record.end());
2948 break;
2949
2950 case EAGERLY_DESERIALIZED_DECLS:
2951 // FIXME: Skip reading this record if our ASTConsumer doesn't care
2952 // about "interesting" decls (for instance, if we're building a module).
2953 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2954 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
2955 break;
2956
2957 case MODULAR_CODEGEN_DECLS:
2958 // FIXME: Skip reading this record if our ASTConsumer doesn't care about
2959 // them (ie: if we're not codegenerating this module).
2960 if (F.Kind == MK_MainFile)
2961 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2962 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
2963 break;
2964
2965 case SPECIAL_TYPES:
2966 if (SpecialTypes.empty()) {
2967 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2968 SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
2969 break;
2970 }
2971
2972 if (SpecialTypes.size() != Record.size()) {
2973 Error("invalid special-types record");
2974 return Failure;
2975 }
2976
2977 for (unsigned I = 0, N = Record.size(); I != N; ++I) {
2978 serialization::TypeID ID = getGlobalTypeID(F, Record[I]);
2979 if (!SpecialTypes[I])
2980 SpecialTypes[I] = ID;
2981 // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate
2982 // merge step?
2983 }
2984 break;
2985
2986 case STATISTICS:
2987 TotalNumStatements += Record[0];
2988 TotalNumMacros += Record[1];
2989 TotalLexicalDeclContexts += Record[2];
2990 TotalVisibleDeclContexts += Record[3];
2991 break;
2992
2993 case UNUSED_FILESCOPED_DECLS:
2994 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2995 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
2996 break;
2997
2998 case DELEGATING_CTORS:
2999 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3000 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
3001 break;
3002
3003 case WEAK_UNDECLARED_IDENTIFIERS:
3004 if (Record.size() % 4 != 0) {
3005 Error("invalid weak identifiers record");
3006 return Failure;
3007 }
3008
3009 // FIXME: Ignore weak undeclared identifiers from non-original PCH
3010 // files. This isn't the way to do it :)
3011 WeakUndeclaredIdentifiers.clear();
3012
3013 // Translate the weak, undeclared identifiers into global IDs.
3014 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
3015 WeakUndeclaredIdentifiers.push_back(
3016 getGlobalIdentifierID(F, Record[I++]));
3017 WeakUndeclaredIdentifiers.push_back(
3018 getGlobalIdentifierID(F, Record[I++]));
3019 WeakUndeclaredIdentifiers.push_back(
3020 ReadSourceLocation(F, Record, I).getRawEncoding());
3021 WeakUndeclaredIdentifiers.push_back(Record[I++]);
3022 }
3023 break;
3024
3025 case SELECTOR_OFFSETS: {
3026 F.SelectorOffsets = (const uint32_t *)Blob.data();
3027 F.LocalNumSelectors = Record[0];
3028 unsigned LocalBaseSelectorID = Record[1];
3029 F.BaseSelectorID = getTotalNumSelectors();
3030
3031 if (F.LocalNumSelectors > 0) {
3032 // Introduce the global -> local mapping for selectors within this
3033 // module.
3034 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
3035
3036 // Introduce the local -> global mapping for selectors within this
3037 // module.
3038 F.SelectorRemap.insertOrReplace(
3039 std::make_pair(LocalBaseSelectorID,
3040 F.BaseSelectorID - LocalBaseSelectorID));
3041
3042 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
3043 }
3044 break;
3045 }
3046
3047 case METHOD_POOL:
3048 F.SelectorLookupTableData = (const unsigned char *)Blob.data();
3049 if (Record[0])
3050 F.SelectorLookupTable
3051 = ASTSelectorLookupTable::Create(
3052 F.SelectorLookupTableData + Record[0],
3053 F.SelectorLookupTableData,
3054 ASTSelectorLookupTrait(*this, F));
3055 TotalNumMethodPoolEntries += Record[1];
3056 break;
3057
3058 case REFERENCED_SELECTOR_POOL:
3059 if (!Record.empty()) {
3060 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
3061 ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
3062 Record[Idx++]));
3063 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
3064 getRawEncoding());
3065 }
3066 }
3067 break;
3068
3069 case PP_CONDITIONAL_STACK:
3070 if (!Record.empty()) {
3071 unsigned Idx = 0, End = Record.size() - 1;
3072 bool ReachedEOFWhileSkipping = Record[Idx++];
3073 llvm::Optional<Preprocessor::PreambleSkipInfo> SkipInfo;
3074 if (ReachedEOFWhileSkipping) {
3075 SourceLocation HashToken = ReadSourceLocation(F, Record, Idx);
3076 SourceLocation IfTokenLoc = ReadSourceLocation(F, Record, Idx);
3077 bool FoundNonSkipPortion = Record[Idx++];
3078 bool FoundElse = Record[Idx++];
3079 SourceLocation ElseLoc = ReadSourceLocation(F, Record, Idx);
3080 SkipInfo.emplace(HashToken, IfTokenLoc, FoundNonSkipPortion,
3081 FoundElse, ElseLoc);
3082 }
3083 SmallVector<PPConditionalInfo, 4> ConditionalStack;
3084 while (Idx < End) {
3085 auto Loc = ReadSourceLocation(F, Record, Idx);
3086 bool WasSkipping = Record[Idx++];
3087 bool FoundNonSkip = Record[Idx++];
3088 bool FoundElse = Record[Idx++];
3089 ConditionalStack.push_back(
3090 {Loc, WasSkipping, FoundNonSkip, FoundElse});
3091 }
3092 PP.setReplayablePreambleConditionalStack(ConditionalStack, SkipInfo);
3093 }
3094 break;
3095
3096 case PP_COUNTER_VALUE:
3097 if (!Record.empty() && Listener)
3098 Listener->ReadCounter(F, Record[0]);
3099 break;
3100
3101 case FILE_SORTED_DECLS:
3102 F.FileSortedDecls = (const DeclID *)Blob.data();
3103 F.NumFileSortedDecls = Record[0];
3104 break;
3105
3106 case SOURCE_LOCATION_OFFSETS: {
3107 F.SLocEntryOffsets = (const uint32_t *)Blob.data();
3108 F.LocalNumSLocEntries = Record[0];
3109 unsigned SLocSpaceSize = Record[1];
3110 std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
3111 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
3112 SLocSpaceSize);
3113 if (!F.SLocEntryBaseID) {
3114 Error("ran out of source locations");
3115 break;
3116 }
3117 // Make our entry in the range map. BaseID is negative and growing, so
3118 // we invert it. Because we invert it, though, we need the other end of
3119 // the range.
3120 unsigned RangeStart =
3121 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
3122 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
3123 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
3124
3125 // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
3126 assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0);
3127 GlobalSLocOffsetMap.insert(
3128 std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
3129 - SLocSpaceSize,&F));
3130
3131 // Initialize the remapping table.
3132 // Invalid stays invalid.
3133 F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
3134 // This module. Base was 2 when being compiled.
3135 F.SLocRemap.insertOrReplace(std::make_pair(2U,
3136 static_cast<int>(F.SLocEntryBaseOffset - 2)));
3137
3138 TotalNumSLocEntries += F.LocalNumSLocEntries;
3139 break;
3140 }
3141
3142 case MODULE_OFFSET_MAP:
3143 F.ModuleOffsetMap = Blob;
3144 break;
3145
3146 case SOURCE_MANAGER_LINE_TABLE:
3147 if (ParseLineTable(F, Record))
3148 return Failure;
3149 break;
3150
3151 case SOURCE_LOCATION_PRELOADS: {
3152 // Need to transform from the local view (1-based IDs) to the global view,
3153 // which is based off F.SLocEntryBaseID.
3154 if (!F.PreloadSLocEntries.empty()) {
3155 Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
3156 return Failure;
3157 }
3158
3159 F.PreloadSLocEntries.swap(Record);
3160 break;
3161 }
3162
3163 case EXT_VECTOR_DECLS:
3164 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3165 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
3166 break;
3167
3168 case VTABLE_USES:
3169 if (Record.size() % 3 != 0) {
3170 Error("Invalid VTABLE_USES record");
3171 return Failure;
3172 }
3173
3174 // Later tables overwrite earlier ones.
3175 // FIXME: Modules will have some trouble with this. This is clearly not
3176 // the right way to do this.
3177 VTableUses.clear();
3178
3179 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
3180 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
3181 VTableUses.push_back(
3182 ReadSourceLocation(F, Record, Idx).getRawEncoding());
3183 VTableUses.push_back(Record[Idx++]);
3184 }
3185 break;
3186
3187 case PENDING_IMPLICIT_INSTANTIATIONS:
3188 if (PendingInstantiations.size() % 2 != 0) {
3189 Error("Invalid existing PendingInstantiations");
3190 return Failure;
3191 }
3192
3193 if (Record.size() % 2 != 0) {
3194 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3195 return Failure;
3196 }
3197
3198 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3199 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
3200 PendingInstantiations.push_back(
3201 ReadSourceLocation(F, Record, I).getRawEncoding());
3202 }
3203 break;
3204
3205 case SEMA_DECL_REFS:
3206 if (Record.size() != 3) {
3207 Error("Invalid SEMA_DECL_REFS block");
3208 return Failure;
3209 }
3210 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3211 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3212 break;
3213
3214 case PPD_ENTITIES_OFFSETS: {
3215 F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
3216 assert(Blob.size() % sizeof(PPEntityOffset) == 0);
3217 F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
3218
3219 unsigned LocalBasePreprocessedEntityID = Record[0];
3220
3221 unsigned StartingID;
3222 if (!PP.getPreprocessingRecord())
3223 PP.createPreprocessingRecord();
3224 if (!PP.getPreprocessingRecord()->getExternalSource())
3225 PP.getPreprocessingRecord()->SetExternalSource(*this);
3226 StartingID
3227 = PP.getPreprocessingRecord()
3228 ->allocateLoadedEntities(F.NumPreprocessedEntities);
3229 F.BasePreprocessedEntityID = StartingID;
3230
3231 if (F.NumPreprocessedEntities > 0) {
3232 // Introduce the global -> local mapping for preprocessed entities in
3233 // this module.
3234 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3235
3236 // Introduce the local -> global mapping for preprocessed entities in
3237 // this module.
3238 F.PreprocessedEntityRemap.insertOrReplace(
3239 std::make_pair(LocalBasePreprocessedEntityID,
3240 F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
3241 }
3242
3243 break;
3244 }
3245
3246 case PPD_SKIPPED_RANGES: {
3247 F.PreprocessedSkippedRangeOffsets = (const PPSkippedRange*)Blob.data();
3248 assert(Blob.size() % sizeof(PPSkippedRange) == 0);
3249 F.NumPreprocessedSkippedRanges = Blob.size() / sizeof(PPSkippedRange);
3250
3251 if (!PP.getPreprocessingRecord())
3252 PP.createPreprocessingRecord();
3253 if (!PP.getPreprocessingRecord()->getExternalSource())
3254 PP.getPreprocessingRecord()->SetExternalSource(*this);
3255 F.BasePreprocessedSkippedRangeID = PP.getPreprocessingRecord()
3256 ->allocateSkippedRanges(F.NumPreprocessedSkippedRanges);
3257
3258 if (F.NumPreprocessedSkippedRanges > 0)
3259 GlobalSkippedRangeMap.insert(
3260 std::make_pair(F.BasePreprocessedSkippedRangeID, &F));
3261 break;
3262 }
3263
3264 case DECL_UPDATE_OFFSETS:
3265 if (Record.size() % 2 != 0) {
3266 Error("invalid DECL_UPDATE_OFFSETS block in AST file");
3267 return Failure;
3268 }
3269 for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
3270 GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
3271 DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3272
3273 // If we've already loaded the decl, perform the updates when we finish
3274 // loading this block.
3275 if (Decl *D = GetExistingDecl(ID))
3276 PendingUpdateRecords.push_back(
3277 PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
3278 }
3279 break;
3280
3281 case OBJC_CATEGORIES_MAP:
3282 if (F.LocalNumObjCCategoriesInMap != 0) {
3283 Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
3284 return Failure;
3285 }
3286
3287 F.LocalNumObjCCategoriesInMap = Record[0];
3288 F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
3289 break;
3290
3291 case OBJC_CATEGORIES:
3292 F.ObjCCategories.swap(Record);
3293 break;
3294
3295 case CUDA_SPECIAL_DECL_REFS:
3296 // Later tables overwrite earlier ones.
3297 // FIXME: Modules will have trouble with this.
3298 CUDASpecialDeclRefs.clear();
3299 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3300 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3301 break;
3302
3303 case HEADER_SEARCH_TABLE:
3304 F.HeaderFileInfoTableData = Blob.data();
3305 F.LocalNumHeaderFileInfos = Record[1];
3306 if (Record[0]) {
3307 F.HeaderFileInfoTable
3308 = HeaderFileInfoLookupTable::Create(
3309 (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
3310 (const unsigned char *)F.HeaderFileInfoTableData,
3311 HeaderFileInfoTrait(*this, F,
3312 &PP.getHeaderSearchInfo(),
3313 Blob.data() + Record[2]));
3314
3315 PP.getHeaderSearchInfo().SetExternalSource(this);
3316 if (!PP.getHeaderSearchInfo().getExternalLookup())
3317 PP.getHeaderSearchInfo().SetExternalLookup(this);
3318 }
3319 break;
3320
3321 case FP_PRAGMA_OPTIONS:
3322 // Later tables overwrite earlier ones.
3323 FPPragmaOptions.swap(Record);
3324 break;
3325
3326 case OPENCL_EXTENSIONS:
3327 for (unsigned I = 0, E = Record.size(); I != E; ) {
3328 auto Name = ReadString(Record, I);
3329 auto &Opt = OpenCLExtensions.OptMap[Name];
3330 Opt.Supported = Record[I++] != 0;
3331 Opt.Enabled = Record[I++] != 0;
3332 Opt.Avail = Record[I++];
3333 Opt.Core = Record[I++];
3334 }
3335 break;
3336
3337 case OPENCL_EXTENSION_TYPES:
3338 for (unsigned I = 0, E = Record.size(); I != E;) {
3339 auto TypeID = static_cast<::TypeID>(Record[I++]);
3340 auto *Type = GetType(TypeID).getTypePtr();
3341 auto NumExt = static_cast<unsigned>(Record[I++]);
3342 for (unsigned II = 0; II != NumExt; ++II) {
3343 auto Ext = ReadString(Record, I);
3344 OpenCLTypeExtMap[Type].insert(Ext);
3345 }
3346 }
3347 break;
3348
3349 case OPENCL_EXTENSION_DECLS:
3350 for (unsigned I = 0, E = Record.size(); I != E;) {
3351 auto DeclID = static_cast<::DeclID>(Record[I++]);
3352 auto *Decl = GetDecl(DeclID);
3353 auto NumExt = static_cast<unsigned>(Record[I++]);
3354 for (unsigned II = 0; II != NumExt; ++II) {
3355 auto Ext = ReadString(Record, I);
3356 OpenCLDeclExtMap[Decl].insert(Ext);
3357 }
3358 }
3359 break;
3360
3361 case TENTATIVE_DEFINITIONS:
3362 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3363 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3364 break;
3365
3366 case KNOWN_NAMESPACES:
3367 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3368 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3369 break;
3370
3371 case UNDEFINED_BUT_USED:
3372 if (UndefinedButUsed.size() % 2 != 0) {
3373 Error("Invalid existing UndefinedButUsed");
3374 return Failure;
3375 }
3376
3377 if (Record.size() % 2 != 0) {
3378 Error("invalid undefined-but-used record");
3379 return Failure;
3380 }
3381 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3382 UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3383 UndefinedButUsed.push_back(
3384 ReadSourceLocation(F, Record, I).getRawEncoding());
3385 }
3386 break;
3387
3388 case DELETE_EXPRS_TO_ANALYZE:
3389 for (unsigned I = 0, N = Record.size(); I != N;) {
3390 DelayedDeleteExprs.push_back(getGlobalDeclID(F, Record[I++]));
3391 const uint64_t Count = Record[I++];
3392 DelayedDeleteExprs.push_back(Count);
3393 for (uint64_t C = 0; C < Count; ++C) {
3394 DelayedDeleteExprs.push_back(ReadSourceLocation(F, Record, I).getRawEncoding());
3395 bool IsArrayForm = Record[I++] == 1;
3396 DelayedDeleteExprs.push_back(IsArrayForm);
3397 }
3398 }
3399 break;
3400
3401 case IMPORTED_MODULES:
3402 if (!F.isModule()) {
3403 // If we aren't loading a module (which has its own exports), make
3404 // all of the imported modules visible.
3405 // FIXME: Deal with macros-only imports.
3406 for (unsigned I = 0, N = Record.size(); I != N; /**/) {
3407 unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3408 SourceLocation Loc = ReadSourceLocation(F, Record, I);
3409 if (GlobalID) {
3410 ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3411 if (DeserializationListener)
3412 DeserializationListener->ModuleImportRead(GlobalID, Loc);
3413 }
3414 }
3415 }
3416 break;
3417
3418 case MACRO_OFFSET: {
3419 if (F.LocalNumMacros != 0) {
3420 Error("duplicate MACRO_OFFSET record in AST file");
3421 return Failure;
3422 }
3423 F.MacroOffsets = (const uint32_t *)Blob.data();
3424 F.LocalNumMacros = Record[0];
3425 unsigned LocalBaseMacroID = Record[1];
3426 F.BaseMacroID = getTotalNumMacros();
3427
3428 if (F.LocalNumMacros > 0) {
3429 // Introduce the global -> local mapping for macros within this module.
3430 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3431
3432 // Introduce the local -> global mapping for macros within this module.
3433 F.MacroRemap.insertOrReplace(
3434 std::make_pair(LocalBaseMacroID,
3435 F.BaseMacroID - LocalBaseMacroID));
3436
3437 MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
3438 }
3439 break;
3440 }
3441
3442 case LATE_PARSED_TEMPLATE:
3443 LateParsedTemplates.append(Record.begin(), Record.end());
3444 break;
3445
3446 case OPTIMIZE_PRAGMA_OPTIONS:
3447 if (Record.size() != 1) {
3448 Error("invalid pragma optimize record");
3449 return Failure;
3450 }
3451 OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
3452 break;
3453
3454 case MSSTRUCT_PRAGMA_OPTIONS:
3455 if (Record.size() != 1) {
3456 Error("invalid pragma ms_struct record");
3457 return Failure;
3458 }
3459 PragmaMSStructState = Record[0];
3460 break;
3461
3462 case POINTERS_TO_MEMBERS_PRAGMA_OPTIONS:
3463 if (Record.size() != 2) {
3464 Error("invalid pragma ms_struct record");
3465 return Failure;
3466 }
3467 PragmaMSPointersToMembersState = Record[0];
3468 PointersToMembersPragmaLocation = ReadSourceLocation(F, Record[1]);
3469 break;
3470
3471 case UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES:
3472 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3473 UnusedLocalTypedefNameCandidates.push_back(
3474 getGlobalDeclID(F, Record[I]));
3475 break;
3476
3477 case CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH:
3478 if (Record.size() != 1) {
3479 Error("invalid cuda pragma options record");
3480 return Failure;
3481 }
3482 ForceCUDAHostDeviceDepth = Record[0];
3483 break;
3484
3485 case PACK_PRAGMA_OPTIONS: {
3486 if (Record.size() < 3) {
3487 Error("invalid pragma pack record");
3488 return Failure;
3489 }
3490 PragmaPackCurrentValue = Record[0];
3491 PragmaPackCurrentLocation = ReadSourceLocation(F, Record[1]);
3492 unsigned NumStackEntries = Record[2];
3493 unsigned Idx = 3;
3494 // Reset the stack when importing a new module.
3495 PragmaPackStack.clear();
3496 for (unsigned I = 0; I < NumStackEntries; ++I) {
3497 PragmaPackStackEntry Entry;
3498 Entry.Value = Record[Idx++];
3499 Entry.Location = ReadSourceLocation(F, Record[Idx++]);
3500 Entry.PushLocation = ReadSourceLocation(F, Record[Idx++]);
3501 PragmaPackStrings.push_back(ReadString(Record, Idx));
3502 Entry.SlotLabel = PragmaPackStrings.back();
3503 PragmaPackStack.push_back(Entry);
3504 }
3505 break;
3506 }
3507 }
3508 }
3509}
3510
3511void ASTReader::ReadModuleOffsetMap(ModuleFile &F) const {
3512 assert(!F.ModuleOffsetMap.empty() && "no module offset map to read");
3513
3514 // Additional remapping information.
3515 const unsigned char *Data = (const unsigned char*)F.ModuleOffsetMap.data();
3516 const unsigned char *DataEnd = Data + F.ModuleOffsetMap.size();
3517 F.ModuleOffsetMap = StringRef();
3518
3519 // If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders.
3520 if (F.SLocRemap.find(0) == F.SLocRemap.end()) {
3521 F.SLocRemap.insert(std::make_pair(0U, 0));
3522 F.SLocRemap.insert(std::make_pair(2U, 1));
3523 }
3524
3525 // Continuous range maps we may be updating in our module.
3526 using RemapBuilder = ContinuousRangeMap<uint32_t, int, 2>::Builder;
3527 RemapBuilder SLocRemap(F.SLocRemap);
3528 RemapBuilder IdentifierRemap(F.IdentifierRemap);
3529 RemapBuilder MacroRemap(F.MacroRemap);
3530 RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap);
3531 RemapBuilder SubmoduleRemap(F.SubmoduleRemap);
3532 RemapBuilder SelectorRemap(F.SelectorRemap);
3533 RemapBuilder DeclRemap(F.DeclRemap);
3534 RemapBuilder TypeRemap(F.TypeRemap);
3535
3536 while (Data < DataEnd) {
3537 // FIXME: Looking up dependency modules by filename is horrible. Let's
3538 // start fixing this with prebuilt and explicit modules and see how it
3539 // goes...
3540 using namespace llvm::support;
3541 ModuleKind Kind = static_cast<ModuleKind>(
3542 endian::readNext<uint8_t, little, unaligned>(Data));
3543 uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
3544 StringRef Name = StringRef((const char*)Data, Len);
3545 Data += Len;
3546 ModuleFile *OM = (Kind == MK_PrebuiltModule || Kind == MK_ExplicitModule
3547 ? ModuleMgr.lookupByModuleName(Name)
3548 : ModuleMgr.lookupByFileName(Name));
3549 if (!OM) {
3550 std::string Msg =
3551 "SourceLocation remap refers to unknown module, cannot find ";
3552 Msg.append(Name);
3553 Error(Msg);
3554 return;
3555 }
3556
3557 uint32_t SLocOffset =
3558 endian::readNext<uint32_t, little, unaligned>(Data);
3559 uint32_t IdentifierIDOffset =
3560 endian::readNext<uint32_t, little, unaligned>(Data);
3561 uint32_t MacroIDOffset =
3562 endian::readNext<uint32_t, little, unaligned>(Data);
3563 uint32_t PreprocessedEntityIDOffset =
3564 endian::readNext<uint32_t, little, unaligned>(Data);
3565 uint32_t SubmoduleIDOffset =
3566 endian::readNext<uint32_t, little, unaligned>(Data);
3567 uint32_t SelectorIDOffset =
3568 endian::readNext<uint32_t, little, unaligned>(Data);
3569 uint32_t DeclIDOffset =
3570 endian::readNext<uint32_t, little, unaligned>(Data);
3571 uint32_t TypeIndexOffset =
3572 endian::readNext<uint32_t, little, unaligned>(Data);
3573
3574 uint32_t None = std::numeric_limits<uint32_t>::max();
3575
3576 auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
3577 RemapBuilder &Remap) {
3578 if (Offset != None)
3579 Remap.insert(std::make_pair(Offset,
3580 static_cast<int>(BaseOffset - Offset)));
3581 };
3582 mapOffset(SLocOffset, OM->SLocEntryBaseOffset, SLocRemap);
3583 mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap);
3584 mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap);
3585 mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID,
3586 PreprocessedEntityRemap);
3587 mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap);
3588 mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap);
3589 mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap);
3590 mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap);
3591
3592 // Global -> local mappings.
3593 F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
3594 }
3595}
3596
3597ASTReader::ASTReadResult
3598ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
3599 const ModuleFile *ImportedBy,
3600 unsigned ClientLoadCapabilities) {
3601 unsigned Idx = 0;
3602 F.ModuleMapPath = ReadPath(F, Record, Idx);
3603
3604 // Try to resolve ModuleName in the current header search context and
3605 // verify that it is found in the same module map file as we saved. If the
3606 // top-level AST file is a main file, skip this check because there is no
3607 // usable header search context.
3608 assert(!F.ModuleName.empty() &&
3609 "MODULE_NAME should come before MODULE_MAP_FILE");
3610 if (F.Kind == MK_ImplicitModule && ModuleMgr.begin()->Kind != MK_MainFile) {
3611 // An implicitly-loaded module file should have its module listed in some
3612 // module map file that we've already loaded.
3613 Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
3614 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
3615 const FileEntry *ModMap = M ? Map.getModuleMapFileForUniquing(M) : nullptr;
3616 // Don't emit module relocation error if we have -fno-validate-pch
3617 if (!PP.getPreprocessorOpts().DisablePCHValidation && !ModMap) {
3618 assert(ImportedBy && "top-level import should be verified");
3619 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) {
3620 if (auto *ASTFE = M ? M->getASTFile() : nullptr) {
3621 // This module was defined by an imported (explicit) module.
3622 Diag(diag::err_module_file_conflict) << F.ModuleName << F.FileName
3623 << ASTFE->getName();
3624 } else {
3625 // This module was built with a different module map.
3626 Diag(diag::err_imported_module_not_found)
3627 << F.ModuleName << F.FileName << ImportedBy->FileName
3628 << F.ModuleMapPath;
3629 // In case it was imported by a PCH, there's a chance the user is
3630 // just missing to include the search path to the directory containing
3631 // the modulemap.
3632 if (ImportedBy->Kind == MK_PCH)
3633 Diag(diag::note_imported_by_pch_module_not_found)
3634 << llvm::sys::path::parent_path(F.ModuleMapPath);
3635 }
3636 }
3637 return OutOfDate;
3638 }
3639
3640 assert(M->Name == F.ModuleName && "found module with different name");
3641
3642 // Check the primary module map file.
3643 const FileEntry *StoredModMap = FileMgr.getFile(F.ModuleMapPath);
3644 if (StoredModMap == nullptr || StoredModMap != ModMap) {
3645 assert(ModMap && "found module is missing module map file");
3646 assert(ImportedBy && "top-level import should be verified");
3647 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3648 Diag(diag::err_imported_module_modmap_changed)
3649 << F.ModuleName << ImportedBy->FileName
3650 << ModMap->getName() << F.ModuleMapPath;
3651 return OutOfDate;
3652 }
3653
3654 llvm::SmallPtrSet<const FileEntry *, 1> AdditionalStoredMaps;
3655 for (unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
3656 // FIXME: we should use input files rather than storing names.
3657 std::string Filename = ReadPath(F, Record, Idx);
3658 const FileEntry *F =
3659 FileMgr.getFile(Filename, false, false);
3660 if (F == nullptr) {
3661 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3662 Error("could not find file '" + Filename +"' referenced by AST file");
3663 return OutOfDate;
3664 }
3665 AdditionalStoredMaps.insert(F);
3666 }
3667
3668 // Check any additional module map files (e.g. module.private.modulemap)
3669 // that are not in the pcm.
3670 if (auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
3671 for (const FileEntry *ModMap : *AdditionalModuleMaps) {
3672 // Remove files that match
3673 // Note: SmallPtrSet::erase is really remove
3674 if (!AdditionalStoredMaps.erase(ModMap)) {
3675 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3676 Diag(diag::err_module_different_modmap)
3677 << F.ModuleName << /*new*/0 << ModMap->getName();
3678 return OutOfDate;
3679 }
3680 }
3681 }
3682
3683 // Check any additional module map files that are in the pcm, but not
3684 // found in header search. Cases that match are already removed.
3685 for (const FileEntry *ModMap : AdditionalStoredMaps) {
3686 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3687 Diag(diag::err_module_different_modmap)
3688 << F.ModuleName << /*not new*/1 << ModMap->getName();
3689 return OutOfDate;
3690 }
3691 }
3692
3693 if (Listener)
3694 Listener->ReadModuleMapFile(F.ModuleMapPath);
3695 return Success;
3696}
3697
3698/// Move the given method to the back of the global list of methods.
3699static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method) {
3700 // Find the entry for this selector in the method pool.
3701 Sema::GlobalMethodPool::iterator Known
3702 = S.MethodPool.find(Method->getSelector());
3703 if (Known == S.MethodPool.end())
3704 return;
3705
3706 // Retrieve the appropriate method list.
3707 ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first
3708 : Known->second.second;
3709 bool Found = false;
3710 for (ObjCMethodList *List = &Start; List; List = List->getNext()) {
3711 if (!Found) {
3712 if (List->getMethod() == Method) {
3713 Found = true;
3714 } else {
3715 // Keep searching.
3716 continue;
3717 }
3718 }
3719
3720 if (List->getNext())
3721 List->setMethod(List->getNext()->getMethod());
3722 else
3723 List->setMethod(Method);
3724 }
3725}
3726
3727void ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner) {
3728 assert(Owner->NameVisibility != Module::Hidden && "nothing to make visible?");
3729 for (Decl *D : Names) {
3730 bool wasHidden = D->isHidden();
3731 D->setVisibleDespiteOwningModule();
3732
3733 if (wasHidden && SemaObj) {
3734 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
3735 moveMethodToBackOfGlobalList(*SemaObj, Method);
3736 }
3737 }
3738 }
3739}
3740
3741void ASTReader::makeModuleVisible(Module *Mod,
3742 Module::NameVisibilityKind NameVisibility,
3743 SourceLocation ImportLoc) {
3744 llvm::SmallPtrSet<Module *, 4> Visited;
3745 SmallVector<Module *, 4> Stack;
3746 Stack.push_back(Mod);
3747 while (!Stack.empty()) {
3748 Mod = Stack.pop_back_val();
3749
3750 if (NameVisibility <= Mod->NameVisibility) {
3751 // This module already has this level of visibility (or greater), so
3752 // there is nothing more to do.
3753 continue;
3754 }
3755
3756 if (!Mod->isAvailable()) {
3757 // Modules that aren't available cannot be made visible.
3758 continue;
3759 }
3760
3761 // Update the module's name visibility.
3762 Mod->NameVisibility = NameVisibility;
3763
3764 // If we've already deserialized any names from this module,
3765 // mark them as visible.
3766 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
3767 if (Hidden != HiddenNamesMap.end()) {
3768 auto HiddenNames = std::move(*Hidden);
3769 HiddenNamesMap.erase(Hidden);
3770 makeNamesVisible(HiddenNames.second, HiddenNames.first);
3771 assert(HiddenNamesMap.find(Mod) == HiddenNamesMap.end() &&
3772 "making names visible added hidden names");
3773 }
3774
3775 // Push any exported modules onto the stack to be marked as visible.
3776 SmallVector<Module *, 16> Exports;
3777 Mod->getExportedModules(Exports);
3778 for (SmallVectorImpl<Module *>::iterator
3779 I = Exports.begin(), E = Exports.end(); I != E; ++I) {
3780 Module *Exported = *I;
3781 if (Visited.insert(Exported).second)
3782 Stack.push_back(Exported);
3783 }
3784 }
3785}
3786
3787/// We've merged the definition \p MergedDef into the existing definition
3788/// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made
3789/// visible.
3790void ASTReader::mergeDefinitionVisibility(NamedDecl *Def,
3791 NamedDecl *MergedDef) {
3792 if (Def->isHidden()) {
3793 // If MergedDef is visible or becomes visible, make the definition visible.
3794 if (!MergedDef->isHidden())
3795 Def->setVisibleDespiteOwningModule();
3796 else {
3797 getContext().mergeDefinitionIntoModule(
3798 Def, MergedDef->getImportedOwningModule(),
3799 /*NotifyListeners*/ false);
3800 PendingMergedDefinitionsToDeduplicate.insert(Def);
3801 }
3802 }
3803}
3804
3805bool ASTReader::loadGlobalIndex() {
3806 if (GlobalIndex)
3807 return false;
3808
3809 if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
3810 !PP.getLangOpts().Modules)
3811 return true;
3812
3813 // Try to load the global index.
3814 TriedLoadingGlobalIndex = true;
3815 StringRef ModuleCachePath
3816 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
3817 std::pair<GlobalModuleIndex *, GlobalModuleIndex::ErrorCode> Result
3818 = GlobalModuleIndex::readIndex(ModuleCachePath);
3819 if (!Result.first)
3820 return true;
3821
3822 GlobalIndex.reset(Result.first);
3823 ModuleMgr.setGlobalIndex(GlobalIndex.get());
3824 return false;
3825}
3826
3827bool ASTReader::isGlobalIndexUnavailable() const {
3828 return PP.getLangOpts().Modules && UseGlobalIndex &&
3829 !hasGlobalIndex() && TriedLoadingGlobalIndex;
3830}
3831
3832static void updateModuleTimestamp(ModuleFile &MF) {
3833 // Overwrite the timestamp file contents so that file's mtime changes.
3834 std::string TimestampFilename = MF.getTimestampFilename();
3835 std::error_code EC;
3836 llvm::raw_fd_ostream OS(TimestampFilename, EC, llvm::sys::fs::F_Text);
3837 if (EC)
3838 return;
3839 OS << "Timestamp file\n";
3840 OS.close();
3841 OS.clear_error(); // Avoid triggering a fatal error.
3842}
3843
3844/// Given a cursor at the start of an AST file, scan ahead and drop the
3845/// cursor into the start of the given block ID, returning false on success and
3846/// true on failure.
3847static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
3848 while (true) {
3849 llvm::BitstreamEntry Entry = Cursor.advance();
3850 switch (Entry.Kind) {
3851 case llvm::BitstreamEntry::Error:
3852 case llvm::BitstreamEntry::EndBlock:
3853 return true;
3854
3855 case llvm::BitstreamEntry::Record:
3856 // Ignore top-level records.
3857 Cursor.skipRecord(Entry.ID);
3858 break;
3859
3860 case llvm::BitstreamEntry::SubBlock:
3861 if (Entry.ID == BlockID) {
3862 if (Cursor.EnterSubBlock(BlockID))
3863 return true;
3864 // Found it!
3865 return false;
3866 }
3867
3868 if (Cursor.SkipBlock())
3869 return true;
3870 }
3871 }
3872}
3873
3874ASTReader::ASTReadResult ASTReader::ReadAST(StringRef FileName,
3875 ModuleKind Type,
3876 SourceLocation ImportLoc,
3877 unsigned ClientLoadCapabilities,
3878 SmallVectorImpl<ImportedSubmodule> *Imported) {
3879 llvm::SaveAndRestore<SourceLocation>
3880 SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
3881
3882 // Defer any pending actions until we get to the end of reading the AST file.
3883 Deserializing AnASTFile(this);
3884
3885 // Bump the generation number.
3886 unsigned PreviousGeneration = 0;
3887 if (ContextObj)
3888 PreviousGeneration = incrementGeneration(*ContextObj);
3889
3890 unsigned NumModules = ModuleMgr.size();
3891 SmallVector<ImportedModule, 4> Loaded;
3892 switch (ASTReadResult ReadResult =
3893 ReadASTCore(FileName, Type, ImportLoc,
3894 /*ImportedBy=*/nullptr, Loaded, 0, 0,
3895 ASTFileSignature(), ClientLoadCapabilities)) {
3896 case Failure:
3897 case Missing:
3898 case OutOfDate:
3899 case VersionMismatch:
3900 case ConfigurationMismatch:
3901 case HadErrors: {
3902 llvm::SmallPtrSet<ModuleFile *, 4> LoadedSet;
3903 for (const ImportedModule &IM : Loaded)
3904 LoadedSet.insert(IM.Mod);
3905
3906 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, LoadedSet,
3907 PP.getLangOpts().Modules
3908 ? &PP.getHeaderSearchInfo().getModuleMap()
3909 : nullptr);
3910
3911 // If we find that any modules are unusable, the global index is going
3912 // to be out-of-date. Just remove it.
3913 GlobalIndex.reset();
3914 ModuleMgr.setGlobalIndex(nullptr);
3915 return ReadResult;
3916 }
3917 case Success:
3918 break;
3919 }
3920
3921 // Here comes stuff that we only do once the entire chain is loaded.
3922
3923 // Load the AST blocks of all of the modules that we loaded.
3924 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3925 MEnd = Loaded.end();
3926 M != MEnd; ++M) {
3927 ModuleFile &F = *M->Mod;
3928
3929 // Read the AST block.
3930 if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities))
3931 return Result;
3932
3933 // Read the extension blocks.
3934 while (!SkipCursorToBlock(F.Stream, EXTENSION_BLOCK_ID)) {
3935 if (ASTReadResult Result = ReadExtensionBlock(F))
3936 return Result;
3937 }
3938
3939 // Once read, set the ModuleFile bit base offset and update the size in
3940 // bits of all files we've seen.
3941 F.GlobalBitOffset = TotalModulesSizeInBits;
3942 TotalModulesSizeInBits += F.SizeInBits;
3943 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
3944
3945 // Preload SLocEntries.
3946 for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
3947 int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
3948 // Load it through the SourceManager and don't call ReadSLocEntry()
3949 // directly because the entry may have already been loaded in which case
3950 // calling ReadSLocEntry() directly would trigger an assertion in
3951 // SourceManager.
3952 SourceMgr.getLoadedSLocEntryByID(Index);
3953 }
3954
3955 // Map the original source file ID into the ID space of the current
3956 // compilation.
3957 if (F.OriginalSourceFileID.isValid()) {
3958 F.OriginalSourceFileID = FileID::get(
3959 F.SLocEntryBaseID + F.OriginalSourceFileID.getOpaqueValue() - 1);
3960 }
3961
3962 // Preload all the pending interesting identifiers by marking them out of
3963 // date.
3964 for (auto Offset : F.PreloadIdentifierOffsets) {
3965 const unsigned char *Data = reinterpret_cast<const unsigned char *>(
3966 F.IdentifierTableData + Offset);
3967
3968 ASTIdentifierLookupTrait Trait(*this, F);
3969 auto KeyDataLen = Trait.ReadKeyDataLength(Data);
3970 auto Key = Trait.ReadKey(Data, KeyDataLen.first);
3971 auto &II = PP.getIdentifierTable().getOwn(Key);
3972 II.setOutOfDate(true);
3973
3974 // Mark this identifier as being from an AST file so that we can track
3975 // whether we need to serialize it.
3976 markIdentifierFromAST(*this, II);
3977
3978 // Associate the ID with the identifier so that the writer can reuse it.
3979 auto ID = Trait.ReadIdentifierID(Data + KeyDataLen.first);
3980 SetIdentifierInfo(ID, &II);
3981 }
3982 }
3983
3984 // Setup the import locations and notify the module manager that we've
3985 // committed to these module files.
3986 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3987 MEnd = Loaded.end();
3988 M != MEnd; ++M) {
3989 ModuleFile &F = *M->Mod;
3990
3991 ModuleMgr.moduleFileAccepted(&F);
3992
3993 // Set the import location.
3994 F.DirectImportLoc = ImportLoc;
3995 // FIXME: We assume that locations from PCH / preamble do not need
3996 // any translation.
3997 if (!M->ImportedBy)
3998 F.ImportLoc = M->ImportLoc;
3999 else
4000 F.ImportLoc = TranslateSourceLocation(*M->ImportedBy, M->ImportLoc);
4001 }
4002
4003 if (!PP.getLangOpts().CPlusPlus ||
4004 (Type != MK_ImplicitModule && Type != MK_ExplicitModule &&
4005 Type != MK_PrebuiltModule)) {
4006 // Mark all of the identifiers in the identifier table as being out of date,
4007 // so that various accessors know to check the loaded modules when the
4008 // identifier is used.
4009 //
4010 // For C++ modules, we don't need information on many identifiers (just
4011 // those that provide macros or are poisoned), so we mark all of
4012 // the interesting ones via PreloadIdentifierOffsets.
4013 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
4014 IdEnd = PP.getIdentifierTable().end();
4015 Id != IdEnd; ++Id)
4016 Id->second->setOutOfDate(true);
4017 }
4018 // Mark selectors as out of date.
4019 for (auto Sel : SelectorGeneration)
4020 SelectorOutOfDate[Sel.first] = true;
4021
4022 // Resolve any unresolved module exports.
4023 for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
4024 UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
4025 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
4026 Module *ResolvedMod = getSubmodule(GlobalID);
4027
4028 switch (Unresolved.Kind) {
4029 case UnresolvedModuleRef::Conflict:
4030 if (ResolvedMod) {
4031 Module::Conflict Conflict;
4032 Conflict.Other = ResolvedMod;
4033 Conflict.Message = Unresolved.String.str();
4034 Unresolved.Mod->Conflicts.push_back(Conflict);
4035 }
4036 continue;
4037
4038 case UnresolvedModuleRef::Import:
4039 if (ResolvedMod)
4040 Unresolved.Mod->Imports.insert(ResolvedMod);
4041 continue;
4042
4043 case UnresolvedModuleRef::Export:
4044 if (ResolvedMod || Unresolved.IsWildcard)
4045 Unresolved.Mod->Exports.push_back(
4046 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
4047 continue;
4048 }
4049 }
4050 UnresolvedModuleRefs.clear();
4051
4052 if (Imported)
4053 Imported->append(ImportedModules.begin(),
4054 ImportedModules.end());
4055
4056 // FIXME: How do we load the 'use'd modules? They may not be submodules.
4057 // Might be unnecessary as use declarations are only used to build the
4058 // module itself.
4059
4060 if (ContextObj)
4061 InitializeContext();
4062
4063 if (SemaObj)
4064 UpdateSema();
4065
4066 if (DeserializationListener)
4067 DeserializationListener->ReaderInitialized(this);
4068
4069 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
4070 if (PrimaryModule.OriginalSourceFileID.isValid()) {
4071 // If this AST file is a precompiled preamble, then set the
4072 // preamble file ID of the source manager to the file source file
4073 // from which the preamble was built.
4074 if (Type == MK_Preamble) {
4075 SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
4076 } else if (Type == MK_MainFile) {
4077 SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
4078 }
4079 }
4080
4081 // For any Objective-C class definitions we have already loaded, make sure
4082 // that we load any additional categories.
4083 if (ContextObj) {
4084 for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
4085 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
4086 ObjCClassesLoaded[I],
4087 PreviousGeneration);
4088 }
4089 }
4090
4091 if (PP.getHeaderSearchInfo()
4092 .getHeaderSearchOpts()
4093 .ModulesValidateOncePerBuildSession) {
4094 // Now we are certain that the module and all modules it depends on are
4095 // up to date. Create or update timestamp files for modules that are
4096 // located in the module cache (not for PCH files that could be anywhere
4097 // in the filesystem).
4098 for (unsigned I = 0, N = Loaded.size(); I != N; ++I) {
4099 ImportedModule &M = Loaded[I];
4100 if (M.Mod->Kind == MK_ImplicitModule) {
4101 updateModuleTimestamp(*M.Mod);
4102 }
4103 }
4104 }
4105
4106 return Success;
4107}
4108
4109static ASTFileSignature readASTFileSignature(StringRef PCH);
4110
4111/// Whether \p Stream starts with the AST/PCH file magic number 'CPCH'.
4112static bool startsWithASTFileMagic(BitstreamCursor &Stream) {
4113 return Stream.canSkipToPos(4) &&
4114 Stream.Read(8) == 'C' &&
4115 Stream.Read(8) == 'P' &&
4116 Stream.Read(8) == 'C' &&
4117 Stream.Read(8) == 'H';
4118}
4119
4120static unsigned moduleKindForDiagnostic(ModuleKind Kind) {
4121 switch (Kind) {
4122 case MK_PCH:
4123 return 0; // PCH
4124 case MK_ImplicitModule:
4125 case MK_ExplicitModule:
4126 case MK_PrebuiltModule:
4127 return 1; // module
4128 case MK_MainFile:
4129 case MK_Preamble:
4130 return 2; // main source file
4131 }
4132 llvm_unreachable("unknown module kind");
4133}
4134
4135ASTReader::ASTReadResult
4136ASTReader::ReadASTCore(StringRef FileName,
4137 ModuleKind Type,
4138 SourceLocation ImportLoc,
4139 ModuleFile *ImportedBy,
4140 SmallVectorImpl<ImportedModule> &Loaded,
4141 off_t ExpectedSize, time_t ExpectedModTime,
4142 ASTFileSignature ExpectedSignature,
4143 unsigned ClientLoadCapabilities) {
4144 ModuleFile *M;
4145 std::string ErrorStr;
4146 ModuleManager::AddModuleResult AddResult
4147 = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy,
4148 getGeneration(), ExpectedSize, ExpectedModTime,
4149 ExpectedSignature, readASTFileSignature,
4150 M, ErrorStr);
4151
4152 switch (AddResult) {
4153 case ModuleManager::AlreadyLoaded:
4154 Diag(diag::remark_module_import)
4155 << M->ModuleName << M->FileName << (ImportedBy ? true : false)
4156 << (ImportedBy ? StringRef(ImportedBy->ModuleName) : StringRef());
4157 return Success;
4158
4159 case ModuleManager::NewlyLoaded:
4160 // Load module file below.
4161 break;
4162
4163 case ModuleManager::Missing:
4164 // The module file was missing; if the client can handle that, return
4165 // it.
4166 if (ClientLoadCapabilities & ARR_Missing)
4167 return Missing;
4168
4169 // Otherwise, return an error.
4170 Diag(diag::err_module_file_not_found) << moduleKindForDiagnostic(Type)
4171 << FileName << !ErrorStr.empty()
4172 << ErrorStr;
4173 return Failure;
4174
4175 case ModuleManager::OutOfDate:
4176 // We couldn't load the module file because it is out-of-date. If the
4177 // client can handle out-of-date, return it.
4178 if (ClientLoadCapabilities & ARR_OutOfDate)
4179 return OutOfDate;
4180
4181 // Otherwise, return an error.
4182 Diag(diag::err_module_file_out_of_date) << moduleKindForDiagnostic(Type)
4183 << FileName << !ErrorStr.empty()
4184 << ErrorStr;
4185 return Failure;
4186 }
4187
4188 assert(M && "Missing module file");
4189
4190 bool ShouldFinalizePCM = false;
4191 auto FinalizeOrDropPCM = llvm::make_scope_exit([&]() {
4192 auto &MC = getModuleManager().getModuleCache();
4193 if (ShouldFinalizePCM)
4194 MC.finalizePCM(FileName);
4195 else
4196 MC.tryToDropPCM(FileName);
4197 });
4198 ModuleFile &F = *M;
4199 BitstreamCursor &Stream = F.Stream;
4200 Stream = BitstreamCursor(PCHContainerRdr.ExtractPCH(*F.Buffer));
4201 F.SizeInBits = F.Buffer->getBufferSize() * 8;
4202
4203 // Sniff for the signature.
4204 if (!startsWithASTFileMagic(Stream)) {
4205 Diag(diag::err_module_file_invalid) << moduleKindForDiagnostic(Type)
4206 << FileName;
4207 return Failure;
4208 }
4209
4210 // This is used for compatibility with older PCH formats.
4211 bool HaveReadControlBlock = false;
4212 while (true) {
4213 llvm::BitstreamEntry Entry = Stream.advance();
4214
4215 switch (Entry.Kind) {
4216 case llvm::BitstreamEntry::Error:
4217 case llvm::BitstreamEntry::Record:
4218 case llvm::BitstreamEntry::EndBlock:
4219 Error("invalid record at top-level of AST file");
4220 return Failure;
4221
4222 case llvm::BitstreamEntry::SubBlock:
4223 break;
4224 }
4225
4226 switch (Entry.ID) {
4227 case CONTROL_BLOCK_ID:
4228 HaveReadControlBlock = true;
4229 switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
4230 case Success:
4231 // Check that we didn't try to load a non-module AST file as a module.
4232 //
4233 // FIXME: Should we also perform the converse check? Loading a module as
4234 // a PCH file sort of works, but it's a bit wonky.
4235 if ((Type == MK_ImplicitModule || Type == MK_ExplicitModule ||
4236 Type == MK_PrebuiltModule) &&
4237 F.ModuleName.empty()) {
4238 auto Result = (Type == MK_ImplicitModule) ? OutOfDate : Failure;
4239 if (Result != OutOfDate ||
4240 (ClientLoadCapabilities & ARR_OutOfDate) == 0)
4241 Diag(diag::err_module_file_not_module) << FileName;
4242 return Result;
4243 }
4244 break;
4245
4246 case Failure: return Failure;
4247 case Missing: return Missing;
4248 case OutOfDate: return OutOfDate;
4249 case VersionMismatch: return VersionMismatch;
4250 case ConfigurationMismatch: return ConfigurationMismatch;
4251 case HadErrors: return HadErrors;
4252 }
4253 break;
4254
4255 case AST_BLOCK_ID:
4256 if (!HaveReadControlBlock) {
4257 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
4258 Diag(diag::err_pch_version_too_old);
4259 return VersionMismatch;
4260 }
4261
4262 // Record that we've loaded this module.
4263 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
4264 ShouldFinalizePCM = true;
4265 return Success;
4266
4267 case UNHASHED_CONTROL_BLOCK_ID:
4268 // This block is handled using look-ahead during ReadControlBlock. We
4269 // shouldn't get here!
4270 Error("malformed block record in AST file");
4271 return Failure;
4272
4273 default:
4274 if (Stream.SkipBlock()) {
4275 Error("malformed block record in AST file");
4276 return Failure;
4277 }
4278 break;
4279 }
4280 }
4281
4282 llvm_unreachable("unexpected break; expected return");
4283}
4284
4285ASTReader::ASTReadResult
4286ASTReader::readUnhashedControlBlock(ModuleFile &F, bool WasImportedBy,
4287 unsigned ClientLoadCapabilities) {
4288 const HeaderSearchOptions &HSOpts =
4289 PP.getHeaderSearchInfo().getHeaderSearchOpts();
4290 bool AllowCompatibleConfigurationMismatch =
4291 F.Kind == MK_ExplicitModule || F.Kind == MK_PrebuiltModule;
4292
4293 ASTReadResult Result = readUnhashedControlBlockImpl(
4294 &F, F.Data, ClientLoadCapabilities, AllowCompatibleConfigurationMismatch,
4295 Listener.get(),
4296 WasImportedBy ? false : HSOpts.ModulesValidateDiagnosticOptions);
4297
4298 // If F was directly imported by another module, it's implicitly validated by
4299 // the importing module.
4300 if (DisableValidation || WasImportedBy ||
4301 (AllowConfigurationMismatch && Result == ConfigurationMismatch))
4302 return Success;
4303
4304 if (Result == Failure) {
4305 Error("malformed block record in AST file");
4306 return Failure;
4307 }
4308
4309 if (Result == OutOfDate && F.Kind == MK_ImplicitModule) {
4310 // If this module has already been finalized in the ModuleCache, we're stuck
4311 // with it; we can only load a single version of each module.
4312 //
4313 // This can happen when a module is imported in two contexts: in one, as a
4314 // user module; in another, as a system module (due to an import from
4315 // another module marked with the [system] flag). It usually indicates a
4316 // bug in the module map: this module should also be marked with [system].
4317 //
4318 // If -Wno-system-headers (the default), and the first import is as a
4319 // system module, then validation will fail during the as-user import,
4320 // since -Werror flags won't have been validated. However, it's reasonable
4321 // to treat this consistently as a system module.
4322 //
4323 // If -Wsystem-headers, the PCM on disk was built with
4324 // -Wno-system-headers, and the first import is as a user module, then
4325 // validation will fail during the as-system import since the PCM on disk
4326 // doesn't guarantee that -Werror was respected. However, the -Werror
4327 // flags were checked during the initial as-user import.
4328 if (getModuleManager().getModuleCache().isPCMFinal(F.FileName)) {
4329 Diag(diag::warn_module_system_bit_conflict) << F.FileName;
4330 return Success;
4331 }
4332 }
4333
4334 return Result;
4335}
4336
4337ASTReader::ASTReadResult ASTReader::readUnhashedControlBlockImpl(
4338 ModuleFile *F, llvm::StringRef StreamData, unsigned ClientLoadCapabilities,
4339 bool AllowCompatibleConfigurationMismatch, ASTReaderListener *Listener,
4340 bool ValidateDiagnosticOptions) {
4341 // Initialize a stream.
4342 BitstreamCursor Stream(StreamData);
4343
4344 // Sniff for the signature.
4345 if (!startsWithASTFileMagic(Stream))
4346 return Failure;
4347
4348 // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4349 if (SkipCursorToBlock(Stream, UNHASHED_CONTROL_BLOCK_ID))
4350 return Failure;
4351
4352 // Read all of the records in the options block.
4353 RecordData Record;
4354 ASTReadResult Result = Success;
4355 while (true) {
4356 llvm::BitstreamEntry Entry = Stream.advance();
4357
4358 switch (Entry.Kind) {
4359 case llvm::BitstreamEntry::Error:
4360 case llvm::BitstreamEntry::SubBlock:
4361 return Failure;
4362
4363 case llvm::BitstreamEntry::EndBlock:
4364 return Result;
4365
4366 case llvm::BitstreamEntry::Record:
4367 // The interesting case.
4368 break;
4369 }
4370
4371 // Read and process a record.
4372 Record.clear();
4373 switch (
4374 (UnhashedControlBlockRecordTypes)Stream.readRecord(Entry.ID, Record)) {
4375 case SIGNATURE:
4376 if (F)
4377 std::copy(Record.begin(), Record.end(), F->Signature.data());
4378 break;
4379 case DIAGNOSTIC_OPTIONS: {
4380 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
4381 if (Listener && ValidateDiagnosticOptions &&
4382 !AllowCompatibleConfigurationMismatch &&
4383 ParseDiagnosticOptions(Record, Complain, *Listener))
4384 Result = OutOfDate; // Don't return early. Read the signature.
4385 break;
4386 }
4387 case DIAG_PRAGMA_MAPPINGS:
4388 if (!F)
4389 break;
4390 if (F->PragmaDiagMappings.empty())
4391 F->PragmaDiagMappings.swap(Record);
4392 else
4393 F->PragmaDiagMappings.insert(F->PragmaDiagMappings.end(),
4394 Record.begin(), Record.end());
4395 break;
4396 }
4397 }
4398}
4399
4400/// Parse a record and blob containing module file extension metadata.
4401static bool parseModuleFileExtensionMetadata(
4402 const SmallVectorImpl<uint64_t> &Record,
4403 StringRef Blob,
4404 ModuleFileExtensionMetadata &Metadata) {
4405 if (Record.size() < 4) return true;
4406
4407 Metadata.MajorVersion = Record[0];
4408 Metadata.MinorVersion = Record[1];
4409
4410 unsigned BlockNameLen = Record[2];
4411 unsigned UserInfoLen = Record[3];
4412
4413 if (BlockNameLen + UserInfoLen > Blob.size()) return true;
4414
4415 Metadata.BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
4416 Metadata.UserInfo = std::string(Blob.data() + BlockNameLen,
4417 Blob.data() + BlockNameLen + UserInfoLen);
4418 return false;
4419}
4420
4421ASTReader::ASTReadResult ASTReader::ReadExtensionBlock(ModuleFile &F) {
4422 BitstreamCursor &Stream = F.Stream;
4423
4424 RecordData Record;
4425 while (true) {
4426 llvm::BitstreamEntry Entry = Stream.advance();
4427 switch (Entry.Kind) {
4428 case llvm::BitstreamEntry::SubBlock:
4429 if (Stream.SkipBlock())
4430 return Failure;
4431
4432 continue;
4433
4434 case llvm::BitstreamEntry::EndBlock:
4435 return Success;
4436
4437 case llvm::BitstreamEntry::Error:
4438 return HadErrors;
4439
4440 case llvm::BitstreamEntry::Record:
4441 break;
4442 }
4443
4444 Record.clear();
4445 StringRef Blob;
4446 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4447 switch (RecCode) {
4448 case EXTENSION_METADATA: {
4449 ModuleFileExtensionMetadata Metadata;
4450 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4451 return Failure;
4452
4453 // Find a module file extension with this block name.
4454 auto Known = ModuleFileExtensions.find(Metadata.BlockName);
4455 if (Known == ModuleFileExtensions.end()) break;
4456
4457 // Form a reader.
4458 if (auto Reader = Known->second->createExtensionReader(Metadata, *this,
4459 F, Stream)) {
4460 F.ExtensionReaders.push_back(std::move(Reader));
4461 }
4462
4463 break;
4464 }
4465 }
4466 }
4467
4468 return Success;
4469}
4470
4471void ASTReader::InitializeContext() {
4472 assert(ContextObj && "no context to initialize");
4473 ASTContext &Context = *ContextObj;
4474
4475 // If there's a listener, notify them that we "read" the translation unit.
4476 if (DeserializationListener)
4477 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
4478 Context.getTranslationUnitDecl());
4479
4480 // FIXME: Find a better way to deal with collisions between these
4481 // built-in types. Right now, we just ignore the problem.
4482
4483 // Load the special types.
4484 if (SpecialTypes.size() >= NumSpecialTypeIDs) {
4485 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
4486 if (!Context.CFConstantStringTypeDecl)
4487 Context.setCFConstantStringType(GetType(String));
4488 }
4489
4490 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
4491 QualType FileType = GetType(File);
4492 if (FileType.isNull()) {
4493 Error("FILE type is NULL");
4494 return;
4495 }
4496
4497 if (!Context.FILEDecl) {
4498 if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
4499 Context.setFILEDecl(Typedef->getDecl());
4500 else {
4501 const TagType *Tag = FileType->getAs<TagType>();
4502 if (!Tag) {
4503 Error("Invalid FILE type in AST file");
4504 return;
4505 }
4506 Context.setFILEDecl(Tag->getDecl());
4507 }
4508 }
4509 }
4510
4511 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
4512 QualType Jmp_bufType = GetType(Jmp_buf);
4513 if (Jmp_bufType.isNull()) {
4514 Error("jmp_buf type is NULL");
4515 return;
4516 }
4517
4518 if (!Context.jmp_bufDecl) {
4519 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
4520 Context.setjmp_bufDecl(Typedef->getDecl());
4521 else {
4522 const TagType *Tag = Jmp_bufType->getAs<TagType>();
4523 if (!Tag) {
4524 Error("Invalid jmp_buf type in AST file");
4525 return;
4526 }
4527 Context.setjmp_bufDecl(Tag->getDecl());
4528 }
4529 }
4530 }
4531
4532 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
4533 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
4534 if (Sigjmp_bufType.isNull()) {
4535 Error("sigjmp_buf type is NULL");
4536 return;
4537 }
4538
4539 if (!Context.sigjmp_bufDecl) {
4540 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
4541 Context.setsigjmp_bufDecl(Typedef->getDecl());
4542 else {
4543 const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
4544 assert(Tag && "Invalid sigjmp_buf type in AST file");
4545 Context.setsigjmp_bufDecl(Tag->getDecl());
4546 }
4547 }
4548 }
4549
4550 if (unsigned ObjCIdRedef
4551 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
4552 if (Context.ObjCIdRedefinitionType.isNull())
4553 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
4554 }
4555
4556 if (unsigned ObjCClassRedef
4557 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
4558 if (Context.ObjCClassRedefinitionType.isNull())
4559 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
4560 }
4561
4562 if (unsigned ObjCSelRedef
4563 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
4564 if (Context.ObjCSelRedefinitionType.isNull())
4565 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
4566 }
4567
4568 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
4569 QualType Ucontext_tType = GetType(Ucontext_t);
4570 if (Ucontext_tType.isNull()) {
4571 Error("ucontext_t type is NULL");
4572 return;
4573 }
4574
4575 if (!Context.ucontext_tDecl) {
4576 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
4577 Context.setucontext_tDecl(Typedef->getDecl());
4578 else {
4579 const TagType *Tag = Ucontext_tType->getAs<TagType>();
4580 assert(Tag && "Invalid ucontext_t type in AST file");
4581 Context.setucontext_tDecl(Tag->getDecl());
4582 }
4583 }
4584 }
4585
4586 if (unsigned Pthread_t = SpecialTypes[SPECIAL_TYPE_PTHREAD_T]) {
4587 QualType Pthread_tType = GetType(Pthread_t);
4588 if (Pthread_tType.isNull()) {
4589 Error("pthread_t type is NULL");
4590 return;
4591 }
4592
4593 if (!Context.pthread_tDecl) {
4594 if (const TypedefType *Typedef = Pthread_tType->getAs<TypedefType>())
4595 Context.setpthread_tDecl(Typedef->getDecl());
4596 else {
4597 const TagType *Tag = Pthread_tType->getAs<TagType>();
4598 assert(Tag && "Invalid pthread_t type in AST file");
4599 Context.setpthread_tDecl(Tag->getDecl());
4600 }
4601 }
4602 }
4603
4604 if (unsigned Pthread_attr_t = SpecialTypes[SPECIAL_TYPE_PTHREAD_ATTR_T]) {
4605 QualType Pthread_attr_tType = GetType(Pthread_attr_t);
4606 if (Pthread_attr_tType.isNull()) {
4607 Error("pthread_attr_t type is NULL");
4608 return;
4609 }
4610
4611 if (!Context.pthread_attr_tDecl) {
4612 if (const TypedefType *Typedef = Pthread_attr_tType->getAs<TypedefType>())
4613 Context.setpthread_attr_tDecl(Typedef->getDecl());
4614 else {
4615 const TagType *Tag = Pthread_attr_tType->getAs<TagType>();
4616 assert(Tag && "Invalid pthread_attr_t type in AST file");
4617 Context.setpthread_attr_tDecl(Tag->getDecl());
4618 }
4619 }
4620 }
4621 }
4622
4623 ReadPragmaDiagnosticMappings(Context.getDiagnostics());
4624
4625 // If there were any CUDA special declarations, deserialize them.
4626 if (!CUDASpecialDeclRefs.empty()) {
4627 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
4628 Context.setcudaConfigureCallDecl(
4629 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
4630 }
4631
4632 // Re-export any modules that were imported by a non-module AST file.
4633 // FIXME: This does not make macro-only imports visible again.
4634 for (auto &Import : ImportedModules) {
4635 if (Module *Imported = getSubmodule(Import.ID)) {
4636 makeModuleVisible(Imported, Module::AllVisible,
4637 /*ImportLoc=*/Import.ImportLoc);
4638 if (Import.ImportLoc.isValid())
4639 PP.makeModuleVisible(Imported, Import.ImportLoc);
4640 // FIXME: should we tell Sema to make the module visible too?
4641 }
4642 }
4643 ImportedModules.clear();
4644}
4645
4646void ASTReader::finalizeForWriting() {
4647 // Nothing to do for now.
4648}
4649
4650/// Reads and return the signature record from \p PCH's control block, or
4651/// else returns 0.
4652static ASTFileSignature readASTFileSignature(StringRef PCH) {
4653 BitstreamCursor Stream(PCH);
4654 if (!startsWithASTFileMagic(Stream))
4655 return ASTFileSignature();
4656
4657 // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4658 if (SkipCursorToBlock(Stream, UNHASHED_CONTROL_BLOCK_ID))
4659 return ASTFileSignature();
4660
4661 // Scan for SIGNATURE inside the diagnostic options block.
4662 ASTReader::RecordData Record;
4663 while (true) {
4664 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4665 if (Entry.Kind != llvm::BitstreamEntry::Record)
4666 return ASTFileSignature();
4667
4668 Record.clear();
4669 StringRef Blob;
4670 if (SIGNATURE == Stream.readRecord(Entry.ID, Record, &Blob))
4671 return {{{(uint32_t)Record[0], (uint32_t)Record[1], (uint32_t)Record[2],
4672 (uint32_t)Record[3], (uint32_t)Record[4]}}};
4673 }
4674}
4675
4676/// Retrieve the name of the original source file name
4677/// directly from the AST file, without actually loading the AST
4678/// file.
4679std::string ASTReader::getOriginalSourceFile(
4680 const std::string &ASTFileName, FileManager &FileMgr,
4681 const PCHContainerReader &PCHContainerRdr, DiagnosticsEngine &Diags) {
4682 // Open the AST file.
4683 auto Buffer = FileMgr.getBufferForFile(ASTFileName);
4684 if (!Buffer) {
4685 Diags.Report(diag::err_fe_unable_to_read_pch_file)
4686 << ASTFileName << Buffer.getError().message();
4687 return std::string();
4688 }
4689
4690 // Initialize the stream
4691 BitstreamCursor Stream(PCHContainerRdr.ExtractPCH(**Buffer));
4692
4693 // Sniff for the signature.
4694 if (!startsWithASTFileMagic(Stream)) {
4695 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
4696 return std::string();
4697 }
4698
4699 // Scan for the CONTROL_BLOCK_ID block.
4700 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) {
4701 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4702 return std::string();
4703 }
4704
4705 // Scan for ORIGINAL_FILE inside the control block.
4706 RecordData Record;
4707 while (true) {
4708 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4709 if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
4710 return std::string();
4711
4712 if (Entry.Kind != llvm::BitstreamEntry::Record) {
4713 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4714 return std::string();
4715 }
4716
4717 Record.clear();
4718 StringRef Blob;
4719 if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE)
4720 return Blob.str();
4721 }
4722}
4723
4724namespace {
4725
4726 class SimplePCHValidator : public ASTReaderListener {
4727 const LangOptions &ExistingLangOpts;
4728 const TargetOptions &ExistingTargetOpts;
4729 const PreprocessorOptions &ExistingPPOpts;
4730 std::string ExistingModuleCachePath;
4731 FileManager &FileMgr;
4732
4733 public:
4734 SimplePCHValidator(const LangOptions &ExistingLangOpts,
4735 const TargetOptions &ExistingTargetOpts,
4736 const PreprocessorOptions &ExistingPPOpts,
4737 StringRef ExistingModuleCachePath,
4738 FileManager &FileMgr)
4739 : ExistingLangOpts(ExistingLangOpts),
4740 ExistingTargetOpts(ExistingTargetOpts),
4741 ExistingPPOpts(ExistingPPOpts),
4742 ExistingModuleCachePath(ExistingModuleCachePath),
4743 FileMgr(FileMgr) {}
4744
4745 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
4746 bool AllowCompatibleDifferences) override {
4747 return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr,
4748 AllowCompatibleDifferences);
4749 }
4750
4751 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
4752 bool AllowCompatibleDifferences) override {
4753 return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr,
4754 AllowCompatibleDifferences);
4755 }
4756
4757 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
4758 StringRef SpecificModuleCachePath,
4759 bool Complain) override {
4760 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
4761 ExistingModuleCachePath,
4762 nullptr, ExistingLangOpts);
4763 }
4764
4765 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
4766 bool Complain,
4767 std::string &SuggestedPredefines) override {
4768 return checkPreprocessorOptions(ExistingPPOpts, PPOpts, nullptr, FileMgr,
4769 SuggestedPredefines, ExistingLangOpts);
4770 }
4771 };
4772
4773} // namespace
4774
4775bool ASTReader::readASTFileControlBlock(
4776 StringRef Filename, FileManager &FileMgr,
4777 const PCHContainerReader &PCHContainerRdr,
4778 bool FindModuleFileExtensions,
4779 ASTReaderListener &Listener, bool ValidateDiagnosticOptions) {
4780 // Open the AST file.
4781 // FIXME: This allows use of the VFS; we do not allow use of the
4782 // VFS when actually loading a module.
4783 auto Buffer = FileMgr.getBufferForFile(Filename);
4784 if (!Buffer) {
4785 return true;
4786 }
4787
4788 // Initialize the stream
4789 StringRef Bytes = PCHContainerRdr.ExtractPCH(**Buffer);
4790 BitstreamCursor Stream(Bytes);
4791
4792 // Sniff for the signature.
4793 if (!startsWithASTFileMagic(Stream))
4794 return true;
4795
4796 // Scan for the CONTROL_BLOCK_ID block.
4797 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
4798 return true;
4799
4800 bool NeedsInputFiles = Listener.needsInputFileVisitation();
4801 bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation();
4802 bool NeedsImports = Listener.needsImportVisitation();
4803 BitstreamCursor InputFilesCursor;
4804
4805 RecordData Record;
4806 std::string ModuleDir;
4807 bool DoneWithControlBlock = false;
4808 while (!DoneWithControlBlock) {
4809 llvm::BitstreamEntry Entry = Stream.advance();
4810
4811 switch (Entry.Kind) {
4812 case llvm::BitstreamEntry::SubBlock: {
4813 switch (Entry.ID) {
4814 case OPTIONS_BLOCK_ID: {
4815 std::string IgnoredSuggestedPredefines;
4816 if (ReadOptionsBlock(Stream, ARR_ConfigurationMismatch | ARR_OutOfDate,
4817 /*AllowCompatibleConfigurationMismatch*/ false,
4818 Listener, IgnoredSuggestedPredefines) != Success)
4819 return true;
4820 break;
4821 }
4822
4823 case INPUT_FILES_BLOCK_ID:
4824 InputFilesCursor = Stream;
4825 if (Stream.SkipBlock() ||
4826 (NeedsInputFiles &&
4827 ReadBlockAbbrevs(InputFilesCursor, INPUT_FILES_BLOCK_ID)))
4828 return true;
4829 break;
4830
4831 default:
4832 if (Stream.SkipBlock())
4833 return true;
4834 break;
4835 }
4836
4837 continue;
4838 }
4839
4840 case llvm::BitstreamEntry::EndBlock:
4841 DoneWithControlBlock = true;
4842 break;
4843
4844 case llvm::BitstreamEntry::Error:
4845 return true;
4846
4847 case llvm::BitstreamEntry::Record:
4848 break;
4849 }
4850
4851 if (DoneWithControlBlock) break;
4852
4853 Record.clear();
4854 StringRef Blob;
4855 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4856 switch ((ControlRecordTypes)RecCode) {
4857 case METADATA:
4858 if (Record[0] != VERSION_MAJOR)
4859 return true;
4860 if (Listener.ReadFullVersionInformation(Blob))
4861 return true;
4862 break;
4863 case MODULE_NAME:
4864 Listener.ReadModuleName(Blob);
4865 break;
4866 case MODULE_DIRECTORY:
4867 ModuleDir = Blob;
4868 break;
4869 case MODULE_MAP_FILE: {
4870 unsigned Idx = 0;
4871 auto Path = ReadString(Record, Idx);
4872 ResolveImportedPath(Path, ModuleDir);
4873 Listener.ReadModuleMapFile(Path);
4874 break;
4875 }
4876 case INPUT_FILE_OFFSETS: {
4877 if (!NeedsInputFiles)
4878 break;
4879
4880 unsigned NumInputFiles = Record[0];
4881 unsigned NumUserFiles = Record[1];
4882 const llvm::support::unaligned_uint64_t *InputFileOffs =
4883 (const llvm::support::unaligned_uint64_t *)Blob.data();
4884 for (unsigned I = 0; I != NumInputFiles; ++I) {
4885 // Go find this input file.
4886 bool isSystemFile = I >= NumUserFiles;
4887
4888 if (isSystemFile && !NeedsSystemInputFiles)
4889 break; // the rest are system input files
4890
4891 BitstreamCursor &Cursor = InputFilesCursor;
4892 SavedStreamPosition SavedPosition(Cursor);
4893 Cursor.JumpToBit(InputFileOffs[I]);
4894
4895 unsigned Code = Cursor.ReadCode();
4896 RecordData Record;
4897 StringRef Blob;
4898 bool shouldContinue = false;
4899 switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) {
4900 case INPUT_FILE:
4901 bool Overridden = static_cast<bool>(Record[3]);
4902 std::string Filename = Blob;
4903 ResolveImportedPath(Filename, ModuleDir);
4904 shouldContinue = Listener.visitInputFile(
4905 Filename, isSystemFile, Overridden, /*IsExplicitModule*/false);
4906 break;
4907 }
4908 if (!shouldContinue)
4909 break;
4910 }
4911 break;
4912 }
4913
4914 case IMPORTS: {
4915 if (!NeedsImports)
4916 break;
4917
4918 unsigned Idx = 0, N = Record.size();
4919 while (Idx < N) {
4920 // Read information about the AST file.
4921 Idx += 1+1+1+1+5; // Kind, ImportLoc, Size, ModTime, Signature
4922 std::string ModuleName = ReadString(Record, Idx);
4923 std::string Filename = ReadString(Record, Idx);
4924 ResolveImportedPath(Filename, ModuleDir);
4925 Listener.visitImport(ModuleName, Filename);
4926 }
4927 break;
4928 }
4929
4930 default:
4931 // No other validation to perform.
4932 break;
4933 }
4934 }
4935
4936 // Look for module file extension blocks, if requested.
4937 if (FindModuleFileExtensions) {
4938 BitstreamCursor SavedStream = Stream;
4939 while (!SkipCursorToBlock(Stream, EXTENSION_BLOCK_ID)) {
4940 bool DoneWithExtensionBlock = false;
4941 while (!DoneWithExtensionBlock) {
4942 llvm::BitstreamEntry Entry = Stream.advance();
4943
4944 switch (Entry.Kind) {
4945 case llvm::BitstreamEntry::SubBlock:
4946 if (Stream.SkipBlock())
4947 return true;
4948
4949 continue;
4950
4951 case llvm::BitstreamEntry::EndBlock:
4952 DoneWithExtensionBlock = true;
4953 continue;
4954
4955 case llvm::BitstreamEntry::Error:
4956 return true;
4957
4958 case llvm::BitstreamEntry::Record:
4959 break;
4960 }
4961
4962 Record.clear();
4963 StringRef Blob;
4964 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4965 switch (RecCode) {
4966 case EXTENSION_METADATA: {
4967 ModuleFileExtensionMetadata Metadata;
4968 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4969 return true;
4970
4971 Listener.readModuleFileExtension(Metadata);
4972 break;
4973 }
4974 }
4975 }
4976 }
4977 Stream = SavedStream;
4978 }
4979
4980 // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4981 if (readUnhashedControlBlockImpl(
4982 nullptr, Bytes, ARR_ConfigurationMismatch | ARR_OutOfDate,
4983 /*AllowCompatibleConfigurationMismatch*/ false, &Listener,
4984 ValidateDiagnosticOptions) != Success)
4985 return true;
4986
4987 return false;
4988}
4989
4990bool ASTReader::isAcceptableASTFile(StringRef Filename, FileManager &FileMgr,
4991 const PCHContainerReader &PCHContainerRdr,
4992 const LangOptions &LangOpts,
4993 const TargetOptions &TargetOpts,
4994 const PreprocessorOptions &PPOpts,
4995 StringRef ExistingModuleCachePath) {
4996 SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
4997 ExistingModuleCachePath, FileMgr);
4998 return !readASTFileControlBlock(Filename, FileMgr, PCHContainerRdr,
4999 /*FindModuleFileExtensions=*/false,
5000 validator,
5001 /*ValidateDiagnosticOptions=*/true);
5002}
5003
5004ASTReader::ASTReadResult
5005ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
5006 // Enter the submodule block.
5007 if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
5008 Error("malformed submodule block record in AST file");
5009 return Failure;
5010 }
5011
5012 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
5013 bool First = true;
5014 Module *CurrentModule = nullptr;
5015 RecordData Record;
5016 while (true) {
5017 llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks();
5018
5019 switch (Entry.Kind) {
5020 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
5021 case llvm::BitstreamEntry::Error:
5022 Error("malformed block record in AST file");
5023 return Failure;
5024 case llvm::BitstreamEntry::EndBlock:
5025 return Success;
5026 case llvm::BitstreamEntry::Record:
5027 // The interesting case.
5028 break;
5029 }
5030
5031 // Read a record.
5032 StringRef Blob;
5033 Record.clear();
5034 auto Kind = F.Stream.readRecord(Entry.ID, Record, &Blob);
5035
5036 if ((Kind == SUBMODULE_METADATA) != First) {
5037 Error("submodule metadata record should be at beginning of block");
5038 return Failure;
5039 }
5040 First = false;
5041
5042 // Submodule information is only valid if we have a current module.
5043 // FIXME: Should we error on these cases?
5044 if (!CurrentModule && Kind != SUBMODULE_METADATA &&
5045 Kind != SUBMODULE_DEFINITION)
5046 continue;
5047
5048 switch (Kind) {
5049 default: // Default behavior: ignore.
5050 break;
5051
5052 case SUBMODULE_DEFINITION: {
5053 if (Record.size() < 12) {
5054 Error("malformed module definition");
5055 return Failure;
5056 }
5057
5058 StringRef Name = Blob;
5059 unsigned Idx = 0;
5060 SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]);
5061 SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]);
5062 Module::ModuleKind Kind = (Module::ModuleKind)Record[Idx++];
5063 bool IsFramework = Record[Idx++];
5064 bool IsExplicit = Record[Idx++];
5065 bool IsSystem = Record[Idx++];
5066 bool IsExternC = Record[Idx++];
5067 bool InferSubmodules = Record[Idx++];
5068 bool InferExplicitSubmodules = Record[Idx++];
5069 bool InferExportWildcard = Record[Idx++];
5070 bool ConfigMacrosExhaustive = Record[Idx++];
5071 bool ModuleMapIsPrivate = Record[Idx++];
5072
5073 Module *ParentModule = nullptr;
5074 if (Parent)
5075 ParentModule = getSubmodule(Parent);
5076
5077 // Retrieve this (sub)module from the module map, creating it if
5078 // necessary.
5079 CurrentModule =
5080 ModMap.findOrCreateModule(Name, ParentModule, IsFramework, IsExplicit)
5081 .first;
5082
5083 // FIXME: set the definition loc for CurrentModule, or call
5084 // ModMap.setInferredModuleAllowedBy()
5085
5086 SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
5087 if (GlobalIndex >= SubmodulesLoaded.size() ||
5088 SubmodulesLoaded[GlobalIndex]) {
5089 Error("too many submodules");
5090 return Failure;
5091 }
5092
5093 if (!ParentModule) {
5094 if (const FileEntry *CurFile = CurrentModule->getASTFile()) {
5095 // Don't emit module relocation error if we have -fno-validate-pch
5096 if (!PP.getPreprocessorOpts().DisablePCHValidation &&
5097 CurFile != F.File) {
5098 if (!Diags.isDiagnosticInFlight()) {
5099 Diag(diag::err_module_file_conflict)
5100 << CurrentModule->getTopLevelModuleName()
5101 << CurFile->getName()
5102 << F.File->getName();
5103 }
5104 return Failure;
5105 }
5106 }
5107
5108 CurrentModule->setASTFile(F.File);
5109 CurrentModule->PresumedModuleMapFile = F.ModuleMapPath;
5110 }
5111
5112 CurrentModule->Kind = Kind;
5113 CurrentModule->Signature = F.Signature;
5114 CurrentModule->IsFromModuleFile = true;
5115 CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
5116 CurrentModule->IsExternC = IsExternC;
5117 CurrentModule->InferSubmodules = InferSubmodules;
5118 CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
5119 CurrentModule->InferExportWildcard = InferExportWildcard;
5120 CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
5121 CurrentModule->ModuleMapIsPrivate = ModuleMapIsPrivate;
5122 if (DeserializationListener)
5123 DeserializationListener->ModuleRead(GlobalID, CurrentModule);
5124
5125 SubmodulesLoaded[GlobalIndex] = CurrentModule;
5126
5127 // Clear out data that will be replaced by what is in the module file.
5128 CurrentModule->LinkLibraries.clear();
5129 CurrentModule->ConfigMacros.clear();
5130 CurrentModule->UnresolvedConflicts.clear();
5131 CurrentModule->Conflicts.clear();
5132
5133 // The module is available unless it's missing a requirement; relevant
5134 // requirements will be (re-)added by SUBMODULE_REQUIRES records.
5135 // Missing headers that were present when the module was built do not
5136 // make it unavailable -- if we got this far, this must be an explicitly
5137 // imported module file.
5138 CurrentModule->Requirements.clear();
5139 CurrentModule->MissingHeaders.clear();
5140 CurrentModule->IsMissingRequirement =
5141 ParentModule && ParentModule->IsMissingRequirement;
5142 CurrentModule->IsAvailable = !CurrentModule->IsMissingRequirement;
5143 break;
5144 }
5145
5146 case SUBMODULE_UMBRELLA_HEADER: {
5147 std::string Filename = Blob;
5148 ResolveImportedPath(F, Filename);
5149 if (auto *Umbrella = PP.getFileManager().getFile(Filename)) {
5150 if (!CurrentModule->getUmbrellaHeader())
5151 ModMap.setUmbrellaHeader(CurrentModule, Umbrella, Blob);
5152 else if (CurrentModule->getUmbrellaHeader().Entry != Umbrella) {
5153 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5154 Error("mismatched umbrella headers in submodule");
5155 return OutOfDate;
5156 }
5157 }
5158 break;
5159 }
5160
5161 case SUBMODULE_HEADER:
5162 case SUBMODULE_EXCLUDED_HEADER:
5163 case SUBMODULE_PRIVATE_HEADER:
5164 // We lazily associate headers with their modules via the HeaderInfo table.
5165 // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
5166 // of complete filenames or remove it entirely.
5167 break;
5168
5169 case SUBMODULE_TEXTUAL_HEADER:
5170 case SUBMODULE_PRIVATE_TEXTUAL_HEADER:
5171 // FIXME: Textual headers are not marked in the HeaderInfo table. Load
5172 // them here.
5173 break;
5174
5175 case SUBMODULE_TOPHEADER:
5176 CurrentModule->addTopHeaderFilename(Blob);
5177 break;
5178
5179 case SUBMODULE_UMBRELLA_DIR: {
5180 std::string Dirname = Blob;
5181 ResolveImportedPath(F, Dirname);
5182 if (auto *Umbrella = PP.getFileManager().getDirectory(Dirname)) {
5183 if (!CurrentModule->getUmbrellaDir())
5184 ModMap.setUmbrellaDir(CurrentModule, Umbrella, Blob);
5185 else if (CurrentModule->getUmbrellaDir().Entry != Umbrella) {
5186 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5187 Error("mismatched umbrella directories in submodule");
5188 return OutOfDate;
5189 }
5190 }
5191 break;
5192 }
5193
5194 case SUBMODULE_METADATA: {
5195 F.BaseSubmoduleID = getTotalNumSubmodules();
5196 F.LocalNumSubmodules = Record[0];
5197 unsigned LocalBaseSubmoduleID = Record[1];
5198 if (F.LocalNumSubmodules > 0) {
5199 // Introduce the global -> local mapping for submodules within this
5200 // module.
5201 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
5202
5203 // Introduce the local -> global mapping for submodules within this
5204 // module.
5205 F.SubmoduleRemap.insertOrReplace(
5206 std::make_pair(LocalBaseSubmoduleID,
5207 F.BaseSubmoduleID - LocalBaseSubmoduleID));
5208
5209 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
5210 }
5211 break;
5212 }
5213
5214 case SUBMODULE_IMPORTS:
5215 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
5216 UnresolvedModuleRef Unresolved;
5217 Unresolved.File = &F;
5218 Unresolved.Mod = CurrentModule;
5219 Unresolved.ID = Record[Idx];
5220 Unresolved.Kind = UnresolvedModuleRef::Import;
5221 Unresolved.IsWildcard = false;
5222 UnresolvedModuleRefs.push_back(Unresolved);
5223 }
5224 break;
5225
5226 case SUBMODULE_EXPORTS:
5227 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
5228 UnresolvedModuleRef Unresolved;
5229 Unresolved.File = &F;
5230 Unresolved.Mod = CurrentModule;
5231 Unresolved.ID = Record[Idx];
5232 Unresolved.Kind = UnresolvedModuleRef::Export;
5233 Unresolved.IsWildcard = Record[Idx + 1];
5234 UnresolvedModuleRefs.push_back(Unresolved);
5235 }
5236
5237 // Once we've loaded the set of exports, there's no reason to keep
5238 // the parsed, unresolved exports around.
5239 CurrentModule->UnresolvedExports.clear();
5240 break;
5241
5242 case SUBMODULE_REQUIRES:
5243 CurrentModule->addRequirement(Blob, Record[0], PP.getLangOpts(),
5244 PP.getTargetInfo());
5245 break;
5246
5247 case SUBMODULE_LINK_LIBRARY:
5248 ModMap.resolveLinkAsDependencies(CurrentModule);
5249 CurrentModule->LinkLibraries.push_back(
5250 Module::LinkLibrary(Blob, Record[0]));
5251 break;
5252
5253 case SUBMODULE_CONFIG_MACRO:
5254 CurrentModule->ConfigMacros.push_back(Blob.str());
5255 break;
5256
5257 case SUBMODULE_CONFLICT: {
5258 UnresolvedModuleRef Unresolved;
5259 Unresolved.File = &F;
5260 Unresolved.Mod = CurrentModule;
5261 Unresolved.ID = Record[0];
5262 Unresolved.Kind = UnresolvedModuleRef::Conflict;
5263 Unresolved.IsWildcard = false;
5264 Unresolved.String = Blob;
5265 UnresolvedModuleRefs.push_back(Unresolved);
5266 break;
5267 }
5268
5269 case SUBMODULE_INITIALIZERS: {
5270 if (!ContextObj)
5271 break;
5272 SmallVector<uint32_t, 16> Inits;
5273 for (auto &ID : Record)
5274 Inits.push_back(getGlobalDeclID(F, ID));
5275 ContextObj->addLazyModuleInitializers(CurrentModule, Inits);
5276 break;
5277 }
5278
5279 case SUBMODULE_EXPORT_AS:
5280 CurrentModule->ExportAsModule = Blob.str();
5281 ModMap.addLinkAsDependency(CurrentModule);
5282 break;
5283 }
5284 }
5285}
5286
5287/// Parse the record that corresponds to a LangOptions data
5288/// structure.
5289///
5290/// This routine parses the language options from the AST file and then gives
5291/// them to the AST listener if one is set.
5292///
5293/// \returns true if the listener deems the file unacceptable, false otherwise.
5294bool ASTReader::ParseLanguageOptions(const RecordData &Record,
5295 bool Complain,
5296 ASTReaderListener &Listener,
5297 bool AllowCompatibleDifferences) {
5298 LangOptions LangOpts;
5299 unsigned Idx = 0;
5300#define LANGOPT(Name, Bits, Default, Description) \
5301 LangOpts.Name = Record[Idx++];
5302#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
5303 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
5304#include "clang/Basic/LangOptions.def"
5305#define SANITIZER(NAME, ID) \
5306 LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
5307#include "clang/Basic/Sanitizers.def"
5308
5309 for (unsigned N = Record[Idx++]; N; --N)
5310 LangOpts.ModuleFeatures.push_back(ReadString(Record, Idx));
5311
5312 ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
5313 VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
5314 LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
5315
5316 LangOpts.CurrentModule = ReadString(Record, Idx);
5317
5318 // Comment options.
5319 for (unsigned N = Record[Idx++]; N; --N) {
5320 LangOpts.CommentOpts.BlockCommandNames.push_back(
5321 ReadString(Record, Idx));
5322 }
5323 LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
5324
5325 // OpenMP offloading options.
5326 for (unsigned N = Record[Idx++]; N; --N) {
5327 LangOpts.OMPTargetTriples.push_back(llvm::Triple(ReadString(Record, Idx)));
5328 }
5329
5330 LangOpts.OMPHostIRFile = ReadString(Record, Idx);
5331
5332 return Listener.ReadLanguageOptions(LangOpts, Complain,
5333 AllowCompatibleDifferences);
5334}
5335
5336bool ASTReader::ParseTargetOptions(const RecordData &Record, bool Complain,
5337 ASTReaderListener &Listener,
5338 bool AllowCompatibleDifferences) {
5339 unsigned Idx = 0;
5340 TargetOptions TargetOpts;
5341 TargetOpts.Triple = ReadString(Record, Idx);
5342 TargetOpts.CPU = ReadString(Record, Idx);
5343 TargetOpts.ABI = ReadString(Record, Idx);
5344 for (unsigned N = Record[Idx++]; N; --N) {
5345 TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
5346 }
5347 for (unsigned N = Record[Idx++]; N; --N) {
5348 TargetOpts.Features.push_back(ReadString(Record, Idx));
5349 }
5350
5351 return Listener.ReadTargetOptions(TargetOpts, Complain,
5352 AllowCompatibleDifferences);
5353}
5354
5355bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
5356 ASTReaderListener &Listener) {
5357 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions);
5358 unsigned Idx = 0;
5359#define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
5360#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
5361 DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
5362#include "clang/Basic/DiagnosticOptions.def"
5363
5364 for (unsigned N = Record[Idx++]; N; --N)
5365 DiagOpts->Warnings.push_back(ReadString(Record, Idx));
5366 for (unsigned N = Record[Idx++]; N; --N)
5367 DiagOpts->Remarks.push_back(ReadString(Record, Idx));
5368
5369 return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
5370}
5371
5372bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
5373 ASTReaderListener &Listener) {
5374 FileSystemOptions FSOpts;
5375 unsigned Idx = 0;
5376 FSOpts.WorkingDir = ReadString(Record, Idx);
5377 return Listener.ReadFileSystemOptions(FSOpts, Complain);
5378}
5379
5380bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
5381 bool Complain,
5382 ASTReaderListener &Listener) {
5383 HeaderSearchOptions HSOpts;
5384 unsigned Idx = 0;
5385 HSOpts.Sysroot = ReadString(Record, Idx);
5386
5387 // Include entries.
5388 for (unsigned N = Record[Idx++]; N; --N) {
5389 std::string Path = ReadString(Record, Idx);
5390 frontend::IncludeDirGroup Group
5391 = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
5392 bool IsFramework = Record[Idx++];
5393 bool IgnoreSysRoot = Record[Idx++];
5394 HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,
5395 IgnoreSysRoot);
5396 }
5397
5398 // System header prefixes.
5399 for (unsigned N = Record[Idx++]; N; --N) {
5400 std::string Prefix = ReadString(Record, Idx);
5401 bool IsSystemHeader = Record[Idx++];
5402 HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
5403 }
5404
5405 HSOpts.ResourceDir = ReadString(Record, Idx);
5406 HSOpts.ModuleCachePath = ReadString(Record, Idx);
5407 HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
5408 HSOpts.DisableModuleHash = Record[Idx++];
5409 HSOpts.ImplicitModuleMaps = Record[Idx++];
5410 HSOpts.ModuleMapFileHomeIsCwd = Record[Idx++];
5411 HSOpts.UseBuiltinIncludes = Record[Idx++];
5412 HSOpts.UseStandardSystemIncludes = Record[Idx++];
5413 HSOpts.UseStandardCXXIncludes = Record[Idx++];
5414 HSOpts.UseLibcxx = Record[Idx++];
5415 std::string SpecificModuleCachePath = ReadString(Record, Idx);
5416
5417 return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
5418 Complain);
5419}
5420
5421bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
5422 bool Complain,
5423 ASTReaderListener &Listener,
5424 std::string &SuggestedPredefines) {
5425 PreprocessorOptions PPOpts;
5426 unsigned Idx = 0;
5427
5428 // Macro definitions/undefs
5429 for (unsigned N = Record[Idx++]; N; --N) {
5430 std::string Macro = ReadString(Record, Idx);
5431 bool IsUndef = Record[Idx++];
5432 PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
5433 }
5434
5435 // Includes
5436 for (unsigned N = Record[Idx++]; N; --N) {
5437 PPOpts.Includes.push_back(ReadString(Record, Idx));
5438 }
5439
5440 // Macro Includes
5441 for (unsigned N = Record[Idx++]; N; --N) {
5442 PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
5443 }
5444
5445 PPOpts.UsePredefines = Record[Idx++];
5446 PPOpts.DetailedRecord = Record[Idx++];
5447 PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
5448 PPOpts.ObjCXXARCStandardLibrary =
5449 static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
5450 SuggestedPredefines.clear();
5451 return Listener.ReadPreprocessorOptions(PPOpts, Complain,
5452 SuggestedPredefines);
5453}
5454
5455std::pair<ModuleFile *, unsigned>
5456ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
5457 GlobalPreprocessedEntityMapType::iterator
5458 I = GlobalPreprocessedEntityMap.find(GlobalIndex);
5459 assert(I != GlobalPreprocessedEntityMap.end() &&
5460 "Corrupted global preprocessed entity map");
5461 ModuleFile *M = I->second;
5462 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
5463 return std::make_pair(M, LocalIndex);
5464}
5465
5466llvm::iterator_range<PreprocessingRecord::iterator>
5467ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
5468 if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
5469 return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
5470 Mod.NumPreprocessedEntities);
5471
5472 return llvm::make_range(PreprocessingRecord::iterator(),
5473 PreprocessingRecord::iterator());
5474}
5475
5476llvm::iterator_range<ASTReader::ModuleDeclIterator>
5477ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) {
5478 return llvm::make_range(
5479 ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
5480 ModuleDeclIterator(this, &Mod,
5481 Mod.FileSortedDecls + Mod.NumFileSortedDecls));
5482}
5483
5484SourceRange ASTReader::ReadSkippedRange(unsigned GlobalIndex) {
5485 auto I = GlobalSkippedRangeMap.find(GlobalIndex);
5486 assert(I != GlobalSkippedRangeMap.end() &&
5487 "Corrupted global skipped range map");
5488 ModuleFile *M = I->second;
5489 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedSkippedRangeID;
5490 assert(LocalIndex < M->NumPreprocessedSkippedRanges);
5491 PPSkippedRange RawRange = M->PreprocessedSkippedRangeOffsets[LocalIndex];
5492 SourceRange Range(TranslateSourceLocation(*M, RawRange.getBegin()),
5493 TranslateSourceLocation(*M, RawRange.getEnd()));
5494 assert(Range.isValid());
5495 return Range;
5496}
5497
5498PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
5499 PreprocessedEntityID PPID = Index+1;
5500 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5501 ModuleFile &M = *PPInfo.first;
5502 unsigned LocalIndex = PPInfo.second;
5503 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5504
5505 if (!PP.getPreprocessingRecord()) {
5506 Error("no preprocessing record");
5507 return nullptr;
5508 }
5509
5510 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
5511 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset);
5512
5513 llvm::BitstreamEntry Entry =
5514 M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
5515 if (Entry.Kind != llvm::BitstreamEntry::Record)
5516 return nullptr;
5517
5518 // Read the record.
5519 SourceRange Range(TranslateSourceLocation(M, PPOffs.getBegin()),
5520 TranslateSourceLocation(M, PPOffs.getEnd()));
5521 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
5522 StringRef Blob;
5523 RecordData Record;
5524 PreprocessorDetailRecordTypes RecType =
5525 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.readRecord(
5526 Entry.ID, Record, &Blob);
5527 switch (RecType) {
5528 case PPD_MACRO_EXPANSION: {
5529 bool isBuiltin = Record[0];
5530 IdentifierInfo *Name = nullptr;
5531 MacroDefinitionRecord *Def = nullptr;
5532 if (isBuiltin)
5533 Name = getLocalIdentifier(M, Record[1]);
5534 else {
5535 PreprocessedEntityID GlobalID =
5536 getGlobalPreprocessedEntityID(M, Record[1]);
5537 Def = cast<MacroDefinitionRecord>(
5538 PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
5539 }
5540
5541 MacroExpansion *ME;
5542 if (isBuiltin)
5543 ME = new (PPRec) MacroExpansion(Name, Range);
5544 else
5545 ME = new (PPRec) MacroExpansion(Def, Range);
5546
5547 return ME;
5548 }
5549
5550 case PPD_MACRO_DEFINITION: {
5551 // Decode the identifier info and then check again; if the macro is
5552 // still defined and associated with the identifier,
5553 IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
5554 MacroDefinitionRecord *MD = new (PPRec) MacroDefinitionRecord(II, Range);
5555
5556 if (DeserializationListener)
5557 DeserializationListener->MacroDefinitionRead(PPID, MD);
5558
5559 return MD;
5560 }
5561
5562 case PPD_INCLUSION_DIRECTIVE: {
5563 const char *FullFileNameStart = Blob.data() + Record[0];
5564 StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
5565 const FileEntry *File = nullptr;
5566 if (!FullFileName.empty())
5567 File = PP.getFileManager().getFile(FullFileName);
5568
5569 // FIXME: Stable encoding
5570 InclusionDirective::InclusionKind Kind
5571 = static_cast<InclusionDirective::InclusionKind>(Record[2]);
5572 InclusionDirective *ID
5573 = new (PPRec) InclusionDirective(PPRec, Kind,
5574 StringRef(Blob.data(), Record[0]),
5575 Record[1], Record[3],
5576 File,
5577 Range);
5578 return ID;
5579 }
5580 }
5581
5582 llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
5583}
5584
5585/// Find the next module that contains entities and return the ID
5586/// of the first entry.
5587///
5588/// \param SLocMapI points at a chunk of a module that contains no
5589/// preprocessed entities or the entities it contains are not the ones we are
5590/// looking for.
5591PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
5592 GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
5593 ++SLocMapI;
5594 for (GlobalSLocOffsetMapType::const_iterator
5595 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
5596 ModuleFile &M = *SLocMapI->second;
5597 if (M.NumPreprocessedEntities)
5598 return M.BasePreprocessedEntityID;
5599 }
5600
5601 return getTotalNumPreprocessedEntities();
5602}
5603
5604namespace {
5605
5606struct PPEntityComp {
5607 const ASTReader &Reader;
5608 ModuleFile &M;
5609
5610 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) {}
5611
5612 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
5613 SourceLocation LHS = getLoc(L);
5614 SourceLocation RHS = getLoc(R);
5615 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5616 }
5617
5618 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
5619 SourceLocation LHS = getLoc(L);
5620 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5621 }
5622
5623 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
5624 SourceLocation RHS = getLoc(R);
5625 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5626 }
5627
5628 SourceLocation getLoc(const PPEntityOffset &PPE) const {
5629 return Reader.TranslateSourceLocation(M, PPE.getBegin());
5630 }
5631};
5632
5633} // namespace
5634
5635PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
5636 bool EndsAfter) const {
5637 if (SourceMgr.isLocalSourceLocation(Loc))
5638 return getTotalNumPreprocessedEntities();
5639
5640 GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
5641 SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
5642 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
5643 "Corrupted global sloc offset map");
5644
5645 if (SLocMapI->second->NumPreprocessedEntities == 0)
5646 return findNextPreprocessedEntity(SLocMapI);
5647
5648 ModuleFile &M = *SLocMapI->second;
5649
5650 using pp_iterator = const PPEntityOffset *;
5651
5652 pp_iterator pp_begin = M.PreprocessedEntityOffsets;
5653 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
5654
5655 size_t Count = M.NumPreprocessedEntities;
5656 size_t Half;
5657 pp_iterator First = pp_begin;
5658 pp_iterator PPI;
5659
5660 if (EndsAfter) {
5661 PPI = std::upper_bound(pp_begin, pp_end, Loc,
5662 PPEntityComp(*this, M));
5663 } else {
5664 // Do a binary search manually instead of using std::lower_bound because
5665 // The end locations of entities may be unordered (when a macro expansion
5666 // is inside another macro argument), but for this case it is not important
5667 // whether we get the first macro expansion or its containing macro.
5668 while (Count > 0) {
5669 Half = Count / 2;
5670 PPI = First;
5671 std::advance(PPI, Half);
5672 if (SourceMgr.isBeforeInTranslationUnit(
5673 TranslateSourceLocation(M, PPI->getEnd()), Loc)) {
5674 First = PPI;
5675 ++First;
5676 Count = Count - Half - 1;
5677 } else
5678 Count = Half;
5679 }
5680 }
5681
5682 if (PPI == pp_end)
5683 return findNextPreprocessedEntity(SLocMapI);
5684
5685 return M.BasePreprocessedEntityID + (PPI - pp_begin);
5686}
5687
5688/// Returns a pair of [Begin, End) indices of preallocated
5689/// preprocessed entities that \arg Range encompasses.
5690std::pair<unsigned, unsigned>
5691 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) {
5692 if (Range.isInvalid())
5693 return std::make_pair(0,0);
5694 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
5695
5696 PreprocessedEntityID BeginID =
5697 findPreprocessedEntity(Range.getBegin(), false);
5698 PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true);
5699 return std::make_pair(BeginID, EndID);
5700}
5701
5702/// Optionally returns true or false if the preallocated preprocessed
5703/// entity with index \arg Index came from file \arg FID.
5704Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index,
5705 FileID FID) {
5706 if (FID.isInvalid())
5707 return false;
5708
5709 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5710 ModuleFile &M = *PPInfo.first;
5711 unsigned LocalIndex = PPInfo.second;
5712 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5713
5714 SourceLocation Loc = TranslateSourceLocation(M, PPOffs.getBegin());
5715 if (Loc.isInvalid())
5716 return false;
5717
5718 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
5719 return true;
5720 else
5721 return false;
5722}
5723
5724namespace {
5725
5726 /// Visitor used to search for information about a header file.
5727 class HeaderFileInfoVisitor {
5728 const FileEntry *FE;
5729 Optional<HeaderFileInfo> HFI;
5730
5731 public:
5732 explicit HeaderFileInfoVisitor(const FileEntry *FE) : FE(FE) {}
5733
5734 bool operator()(ModuleFile &M) {
5735 HeaderFileInfoLookupTable *Table
5736 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
5737 if (!Table)
5738 return false;
5739
5740 // Look in the on-disk hash table for an entry for this file name.
5741 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
5742 if (Pos == Table->end())
5743 return false;
5744
5745 HFI = *Pos;
5746 return true;
5747 }
5748
5749 Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
5750 };
5751
5752} // namespace
5753
5754HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
5755 HeaderFileInfoVisitor Visitor(FE);
5756 ModuleMgr.visit(Visitor);
5757 if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
5758 return *HFI;
5759
5760 return HeaderFileInfo();
5761}
5762
5763void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) {
5764 using DiagState = DiagnosticsEngine::DiagState;
5765 SmallVector<DiagState *, 32> DiagStates;
5766
5767 for (ModuleFile &F : ModuleMgr) {
5768 unsigned Idx = 0;
5769 auto &Record = F.PragmaDiagMappings;
5770 if (Record.empty())
5771 continue;
5772
5773 DiagStates.clear();
5774
5775 auto ReadDiagState =
5776 [&](const DiagState &BasedOn, SourceLocation Loc,
5777 bool IncludeNonPragmaStates) -> DiagnosticsEngine::DiagState * {
5778 unsigned BackrefID = Record[Idx++];
5779 if (BackrefID != 0)
5780 return DiagStates[BackrefID - 1];
5781
5782 // A new DiagState was created here.
5783 Diag.DiagStates.push_back(BasedOn);
5784 DiagState *NewState = &Diag.DiagStates.back();
5785 DiagStates.push_back(NewState);
5786 unsigned Size = Record[Idx++];
5787 assert(Idx + Size * 2 <= Record.size() &&
5788 "Invalid data, not enough diag/map pairs");
5789 while (Size--) {
5790 unsigned DiagID = Record[Idx++];
5791 DiagnosticMapping NewMapping =
5792 DiagnosticMapping::deserialize(Record[Idx++]);
5793 if (!NewMapping.isPragma() && !IncludeNonPragmaStates)
5794 continue;
5795
5796 DiagnosticMapping &Mapping = NewState->getOrAddMapping(DiagID);
5797
5798 // If this mapping was specified as a warning but the severity was
5799 // upgraded due to diagnostic settings, simulate the current diagnostic
5800 // settings (and use a warning).
5801 if (NewMapping.wasUpgradedFromWarning() && !Mapping.isErrorOrFatal()) {
5802 NewMapping.setSeverity(diag::Severity::Warning);
5803 NewMapping.setUpgradedFromWarning(false);
5804 }
5805
5806 Mapping = NewMapping;
5807 }
5808 return NewState;
5809 };
5810
5811 // Read the first state.
5812 DiagState *FirstState;
5813 if (F.Kind == MK_ImplicitModule) {
5814 // Implicitly-built modules are reused with different diagnostic
5815 // settings. Use the initial diagnostic state from Diag to simulate this
5816 // compilation's diagnostic settings.
5817 FirstState = Diag.DiagStatesByLoc.FirstDiagState;
5818 DiagStates.push_back(FirstState);
5819
5820 // Skip the initial diagnostic state from the serialized module.
5821 assert(Record[1] == 0 &&
5822 "Invalid data, unexpected backref in initial state");
5823 Idx = 3 + Record[2] * 2;
5824 assert(Idx < Record.size() &&
5825 "Invalid data, not enough state change pairs in initial state");
5826 } else if (F.isModule()) {
5827 // For an explicit module, preserve the flags from the module build
5828 // command line (-w, -Weverything, -Werror, ...) along with any explicit
5829 // -Wblah flags.
5830 unsigned Flags = Record[Idx++];
5831 DiagState Initial;
5832 Initial.SuppressSystemWarnings = Flags & 1; Flags >>= 1;
5833 Initial.ErrorsAsFatal = Flags & 1; Flags >>= 1;
5834 Initial.WarningsAsErrors = Flags & 1; Flags >>= 1;
5835 Initial.EnableAllWarnings = Flags & 1; Flags >>= 1;
5836 Initial.IgnoreAllWarnings = Flags & 1; Flags >>= 1;
5837 Initial.ExtBehavior = (diag::Severity)Flags;
5838 FirstState = ReadDiagState(Initial, SourceLocation(), true);
5839
5840 assert(F.OriginalSourceFileID.isValid());
5841
5842 // Set up the root buffer of the module to start with the initial
5843 // diagnostic state of the module itself, to cover files that contain no
5844 // explicit transitions (for which we did not serialize anything).
5845 Diag.DiagStatesByLoc.Files[F.OriginalSourceFileID]
5846 .StateTransitions.push_back({FirstState, 0});
5847 } else {
5848 // For prefix ASTs, start with whatever the user configured on the
5849 // command line.
5850 Idx++; // Skip flags.
5851 FirstState = ReadDiagState(*Diag.DiagStatesByLoc.CurDiagState,
5852 SourceLocation(), false);
5853 }
5854
5855 // Read the state transitions.
5856 unsigned NumLocations = Record[Idx++];
5857 while (NumLocations--) {
5858 assert(Idx < Record.size() &&
5859 "Invalid data, missing pragma diagnostic states");
5860 SourceLocation Loc = ReadSourceLocation(F, Record[Idx++]);
5861 auto IDAndOffset = SourceMgr.getDecomposedLoc(Loc);
5862 assert(IDAndOffset.first.isValid() && "invalid FileID for transition");
5863 assert(IDAndOffset.second == 0 && "not a start location for a FileID");
5864 unsigned Transitions = Record[Idx++];
5865
5866 // Note that we don't need to set up Parent/ParentOffset here, because
5867 // we won't be changing the diagnostic state within imported FileIDs
5868 // (other than perhaps appending to the main source file, which has no
5869 // parent).
5870 auto &F = Diag.DiagStatesByLoc.Files[IDAndOffset.first];
5871 F.StateTransitions.reserve(F.StateTransitions.size() + Transitions);
5872 for (unsigned I = 0; I != Transitions; ++I) {
5873 unsigned Offset = Record[Idx++];
5874 auto *State =
5875 ReadDiagState(*FirstState, Loc.getLocWithOffset(Offset), false);
5876 F.StateTransitions.push_back({State, Offset});
5877 }
5878 }
5879
5880 // Read the final state.
5881 assert(Idx < Record.size() &&
5882 "Invalid data, missing final pragma diagnostic state");
5883 SourceLocation CurStateLoc =
5884 ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
5885 auto *CurState = ReadDiagState(*FirstState, CurStateLoc, false);
5886
5887 if (!F.isModule()) {
5888 Diag.DiagStatesByLoc.CurDiagState = CurState;
5889 Diag.DiagStatesByLoc.CurDiagStateLoc = CurStateLoc;
5890
5891 // Preserve the property that the imaginary root file describes the
5892 // current state.
5893 FileID NullFile;
5894 auto &T = Diag.DiagStatesByLoc.Files[NullFile].StateTransitions;
5895 if (T.empty())
5896 T.push_back({CurState, 0});
5897 else
5898 T[0].State = CurState;
5899 }
5900
5901 // Don't try to read these mappings again.
5902 Record.clear();
5903 }
5904}
5905
5906/// Get the correct cursor and offset for loading a type.
5907ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
5908 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
5909 assert(I != GlobalTypeMap.end() && "Corrupted global type map");
5910 ModuleFile *M = I->second;
5911 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
5912}
5913
5914/// Read and return the type with the given index..
5915///
5916/// The index is the type ID, shifted and minus the number of predefs. This
5917/// routine actually reads the record corresponding to the type at the given
5918/// location. It is a helper routine for GetType, which deals with reading type
5919/// IDs.
5920QualType ASTReader::readTypeRecord(unsigned Index) {
5921 assert(ContextObj && "reading type with no AST context");
5922 ASTContext &Context = *ContextObj;
5923 RecordLocation Loc = TypeCursorForIndex(Index);
5924 BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
5925
5926 // Keep track of where we are in the stream, then jump back there
5927 // after reading this type.
5928 SavedStreamPosition SavedPosition(DeclsCursor);
5929
5930 ReadingKindTracker ReadingKind(Read_Type, *this);
5931
5932 // Note that we are loading a type record.
5933 Deserializing AType(this);
5934
5935 unsigned Idx = 0;
5936 DeclsCursor.JumpToBit(Loc.Offset);
5937 RecordData Record;
5938 unsigned Code = DeclsCursor.ReadCode();
5939 switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) {
5940 case TYPE_EXT_QUAL: {
5941 if (Record.size() != 2) {
5942 Error("Incorrect encoding of extended qualifier type");
5943 return QualType();
5944 }
5945 QualType Base = readType(*Loc.F, Record, Idx);
5946 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
5947 return Context.getQualifiedType(Base, Quals);
5948 }
5949
5950 case TYPE_COMPLEX: {
5951 if (Record.size() != 1) {
5952 Error("Incorrect encoding of complex type");
5953 return QualType();
5954 }
5955 QualType ElemType = readType(*Loc.F, Record, Idx);
5956 return Context.getComplexType(ElemType);
5957 }
5958
5959 case TYPE_POINTER: {
5960 if (Record.size() != 2) {
5961 Error("Incorrect encoding of pointer type");
5962 return QualType();
5963 }
5964 QualType PointeeType = readType(*Loc.F, Record, Idx);
5965 return Context.getPointerType(PointeeType, Record[1] ? ASTContext::PIK_Capability : ASTContext::PIK_Integer);
5966 }
5967
5968 case TYPE_DECAYED: {
5969 if (Record.size() != 1) {
5970 Error("Incorrect encoding of decayed type");
5971 return QualType();
5972 }
5973 QualType OriginalType = readType(*Loc.F, Record, Idx);
5974 QualType DT = Context.getAdjustedParameterType(OriginalType);
5975 if (!isa<DecayedType>(DT))
5976 Error("Decayed type does not decay");
5977 return DT;
5978 }
5979
5980 case TYPE_ADJUSTED: {
5981 if (Record.size() != 2) {
5982 Error("Incorrect encoding of adjusted type");
5983 return QualType();
5984 }
5985 QualType OriginalTy = readType(*Loc.F, Record, Idx);
5986 QualType AdjustedTy = readType(*Loc.F, Record, Idx);
5987 return Context.getAdjustedType(OriginalTy, AdjustedTy);
5988 }
5989
5990 case TYPE_BLOCK_POINTER: {
5991 if (Record.size() != 1) {
5992 Error("Incorrect encoding of block pointer type");
5993 return QualType();
5994 }
5995 QualType PointeeType = readType(*Loc.F, Record, Idx);
5996 return Context.getBlockPointerType(PointeeType);
5997 }
5998
5999 case TYPE_LVALUE_REFERENCE: {
6000 if (Record.size() != 3) {
6001 Error("Incorrect encoding of lvalue reference type");
6002 return QualType();
6003 }
6004 QualType PointeeType = readType(*Loc.F, Record, Idx);
6005 return Context.getLValueReferenceType(PointeeType, Record[1], Record[2] ? ASTContext::PIK_Capability : ASTContext::PIK_Integer);
6006 }
6007
6008 case TYPE_RVALUE_REFERENCE: {
6009 if (Record.size() != 2) {
6010 Error("Incorrect encoding of rvalue reference type");
6011 return QualType();
6012 }
6013 QualType PointeeType = readType(*Loc.F, Record, Idx);
6014 return Context.getRValueReferenceType(PointeeType, Record[1] ? ASTContext::PIK_Capability : ASTContext::PIK_Integer);
6015 }
6016
6017 case TYPE_MEMBER_POINTER: {
6018 if (Record.size() != 2) {
6019 Error("Incorrect encoding of member pointer type");
6020 return QualType();
6021 }
6022 QualType PointeeType = readType(*Loc.F, Record, Idx);
6023 QualType ClassType = readType(*Loc.F, Record, Idx);
6024 if (PointeeType.isNull() || ClassType.isNull())
6025 return QualType();
6026
6027 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
6028 }
6029
6030 case TYPE_CONSTANT_ARRAY: {
6031 QualType ElementType = readType(*Loc.F, Record, Idx);
6032 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
6033 unsigned IndexTypeQuals = Record[2];
6034 unsigned Idx = 3;
6035 llvm::APInt Size = ReadAPInt(Record, Idx);
6036 return Context.getConstantArrayType(ElementType, Size,
6037 ASM, IndexTypeQuals);
6038 }
6039
6040 case TYPE_INCOMPLETE_ARRAY: {
6041 QualType ElementType = readType(*Loc.F, Record, Idx);
6042 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
6043 unsigned IndexTypeQuals = Record[2];
6044 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
6045 }
6046
6047 case TYPE_VARIABLE_ARRAY: {
6048 QualType ElementType = readType(*Loc.F, Record, Idx);
6049 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
6050 unsigned IndexTypeQuals = Record[2];
6051 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
6052 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
6053 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
6054 ASM, IndexTypeQuals,
6055 SourceRange(LBLoc, RBLoc));
6056 }
6057
6058 case TYPE_VECTOR: {
6059 if (Record.size() != 3) {
6060 Error("incorrect encoding of vector type in AST file");
6061 return QualType();
6062 }
6063
6064 QualType ElementType = readType(*Loc.F, Record, Idx);
6065 unsigned NumElements = Record[1];
6066 unsigned VecKind = Record[2];
6067 return Context.getVectorType(ElementType, NumElements,
6068 (VectorType::VectorKind)VecKind);
6069 }
6070
6071 case TYPE_EXT_VECTOR: {
6072 if (Record.size() != 3) {
6073 Error("incorrect encoding of extended vector type in AST file");
6074 return QualType();
6075 }
6076
6077 QualType ElementType = readType(*Loc.F, Record, Idx);
6078 unsigned NumElements = Record[1];
6079 return Context.getExtVectorType(ElementType, NumElements);
6080 }
6081
6082 case TYPE_FUNCTION_NO_PROTO: {
6083 if (Record.size() != 8) {
6084 Error("incorrect encoding of no-proto function type");
6085 return QualType();
6086 }
6087 QualType ResultType = readType(*Loc.F, Record, Idx);
6088 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
6089 (CallingConv)Record[4], Record[5], Record[6],
6090 Record[7]);
6091 return Context.getFunctionNoProtoType(ResultType, Info);
6092 }
6093
6094 case TYPE_FUNCTION_PROTO: {
6095 QualType ResultType = readType(*Loc.F, Record, Idx);
6096
6097 FunctionProtoType::ExtProtoInfo EPI;
6098 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
6099 /*hasregparm*/ Record[2],
6100 /*regparm*/ Record[3],
6101 static_cast<CallingConv>(Record[4]),
6102 /*produces*/ Record[5],
6103 /*nocallersavedregs*/ Record[6],
6104 /*nocfcheck*/ Record[7]);
6105
6106 unsigned Idx = 8;
6107
6108 EPI.Variadic = Record[Idx++];
6109 EPI.HasTrailingReturn = Record[Idx++];
6110 EPI.TypeQuals = Qualifiers::fromOpaqueValue(Record[Idx++]);
6111 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
6112 SmallVector<QualType, 8> ExceptionStorage;
6113 readExceptionSpec(*Loc.F, ExceptionStorage, EPI.ExceptionSpec, Record, Idx);
6114
6115 unsigned NumParams = Record[Idx++];
6116 SmallVector<QualType, 16> ParamTypes;
6117 for (unsigned I = 0; I != NumParams; ++I)
6118 ParamTypes.push_back(readType(*Loc.F, Record, Idx));
6119
6120 SmallVector<FunctionProtoType::ExtParameterInfo, 4> ExtParameterInfos;
6121 if (Idx != Record.size()) {
6122 for (unsigned I = 0; I != NumParams; ++I)
6123 ExtParameterInfos.push_back(
6124 FunctionProtoType::ExtParameterInfo
6125 ::getFromOpaqueValue(Record[Idx++]));
6126 EPI.ExtParameterInfos = ExtParameterInfos.data();
6127 }
6128
6129 assert(Idx == Record.size());
6130
6131 return Context.getFunctionType(ResultType, ParamTypes, EPI);
6132 }
6133
6134 case TYPE_UNRESOLVED_USING: {
6135 unsigned Idx = 0;
6136 return Context.getTypeDeclType(
6137 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
6138 }
6139
6140 case TYPE_TYPEDEF: {
6141 if (Record.size() != 2) {
6142 Error("incorrect encoding of typedef type");
6143 return QualType();
6144 }
6145 unsigned Idx = 0;
6146 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
6147 QualType Canonical = readType(*Loc.F, Record, Idx);
6148 if (!Canonical.isNull())
6149 Canonical = Context.getCanonicalType(Canonical);
6150 return Context.getTypedefType(Decl, Canonical);
6151 }
6152
6153 case TYPE_TYPEOF_EXPR:
6154 return Context.getTypeOfExprType(ReadExpr(*Loc.F));
6155
6156 case TYPE_TYPEOF: {
6157 if (Record.size() != 1) {
6158 Error("incorrect encoding of typeof(type) in AST file");
6159 return QualType();
6160 }
6161 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
6162 return Context.getTypeOfType(UnderlyingType);
6163 }
6164
6165 case TYPE_DECLTYPE: {
6166 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
6167 return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
6168 }
6169
6170 case TYPE_UNARY_TRANSFORM: {
6171 QualType BaseType = readType(*Loc.F, Record, Idx);
6172 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
6173 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
6174 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
6175 }
6176
6177 case TYPE_AUTO: {
6178 QualType Deduced = readType(*Loc.F, Record, Idx);
6179 AutoTypeKeyword Keyword = (AutoTypeKeyword)Record[Idx++];
6180 bool IsDependent = false, IsPack = false;
6181 if (Deduced.isNull()) {
6182 IsDependent = Record[Idx] > 0;
6183 IsPack = Record[Idx] > 1;
6184 ++Idx;
6185 }
6186 return Context.getAutoType(Deduced, Keyword, IsDependent, IsPack);
6187 }
6188
6189 case TYPE_DEDUCED_TEMPLATE_SPECIALIZATION: {
6190 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
6191 QualType Deduced = readType(*Loc.F, Record, Idx);
6192 bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
6193 return Context.getDeducedTemplateSpecializationType(Name, Deduced,
6194 IsDependent);
6195 }
6196
6197 case TYPE_RECORD: {
6198 if (Record.size() != 2) {
6199 Error("incorrect encoding of record type");
6200 return QualType();
6201 }
6202 unsigned Idx = 0;
6203 bool IsDependent = Record[Idx++];
6204 RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx);
6205 RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl());
6206 QualType T = Context.getRecordType(RD);
6207 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6208 return T;
6209 }
6210
6211 case TYPE_ENUM: {
6212 if (Record.size() != 2) {
6213 Error("incorrect encoding of enum type");
6214 return QualType();
6215 }
6216 unsigned Idx = 0;
6217 bool IsDependent = Record[Idx++];
6218 QualType T
6219 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
6220 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6221 return T;
6222 }
6223
6224 case TYPE_ATTRIBUTED: {
6225 if (Record.size() != 3) {
6226 Error("incorrect encoding of attributed type");
6227 return QualType();
6228 }
6229 QualType modifiedType = readType(*Loc.F, Record, Idx);
6230 QualType equivalentType = readType(*Loc.F, Record, Idx);
6231 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
6232 return Context.getAttributedType(kind, modifiedType, equivalentType);
6233 }
6234
6235 case TYPE_PAREN: {
6236 if (Record.size() != 1) {
6237 Error("incorrect encoding of paren type");
6238 return QualType();
6239 }
6240 QualType InnerType = readType(*Loc.F, Record, Idx);
6241 return Context.getParenType(InnerType);
6242 }
6243
6244 case TYPE_MACRO_QUALIFIED: {
6245 if (Record.size() != 2) {
6246 Error("incorrect encoding of macro defined type");
6247 return QualType();
6248 }
6249 QualType UnderlyingTy = readType(*Loc.F, Record, Idx);
6250 IdentifierInfo *MacroII = GetIdentifierInfo(*Loc.F, Record, Idx);
6251 return Context.getMacroQualifiedType(UnderlyingTy, MacroII);
6252 }
6253
6254 case TYPE_PACK_EXPANSION: {
6255 if (Record.size() != 2) {
6256 Error("incorrect encoding of pack expansion type");
6257 return QualType();
6258 }
6259 QualType Pattern = readType(*Loc.F, Record, Idx);
6260 if (Pattern.isNull())
6261 return QualType();
6262 Optional<unsigned> NumExpansions;
6263 if (Record[1])
6264 NumExpansions = Record[1] - 1;
6265 return Context.getPackExpansionType(Pattern, NumExpansions);
6266 }
6267
6268 case TYPE_ELABORATED: {
6269 unsigned Idx = 0;
6270 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6271 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6272 QualType NamedType = readType(*Loc.F, Record, Idx);
6273 TagDecl *OwnedTagDecl = ReadDeclAs<TagDecl>(*Loc.F, Record, Idx);
6274 return Context.getElaboratedType(Keyword, NNS, NamedType, OwnedTagDecl);
6275 }
6276
6277 case TYPE_OBJC_INTERFACE: {
6278 unsigned Idx = 0;
6279 ObjCInterfaceDecl *ItfD
6280 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
6281 return Context.getObjCInterfaceType(ItfD->getCanonicalDecl());
6282 }
6283
6284 case TYPE_OBJC_TYPE_PARAM: {
6285 unsigned Idx = 0;
6286 ObjCTypeParamDecl *Decl
6287 = ReadDeclAs<ObjCTypeParamDecl>(*Loc.F, Record, Idx);
6288 unsigned NumProtos = Record[Idx++];
6289 SmallVector<ObjCProtocolDecl*, 4> Protos;
6290 for (unsigned I = 0; I != NumProtos; ++I)
6291 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
6292 return Context.getObjCTypeParamType(Decl, Protos);
6293 }
6294
6295 case TYPE_OBJC_OBJECT: {
6296 unsigned Idx = 0;
6297 QualType Base = readType(*Loc.F, Record, Idx);
6298 unsigned NumTypeArgs = Record[Idx++];
6299 SmallVector<QualType, 4> TypeArgs;
6300 for (unsigned I = 0; I != NumTypeArgs; ++I)
6301 TypeArgs.push_back(readType(*Loc.F, Record, Idx));
6302 unsigned NumProtos = Record[Idx++];
6303 SmallVector<ObjCProtocolDecl*, 4> Protos;
6304 for (unsigned I = 0; I != NumProtos; ++I)
6305 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
6306 bool IsKindOf = Record[Idx++];
6307 return Context.getObjCObjectType(Base, TypeArgs, Protos, IsKindOf);
6308 }
6309
6310 case TYPE_OBJC_OBJECT_POINTER: {
6311 unsigned Idx = 0;
6312 QualType Pointee = readType(*Loc.F, Record, Idx);
6313 return Context.getObjCObjectPointerType(Pointee);
6314 }
6315
6316 case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
6317 unsigned Idx = 0;
6318 QualType Parm = readType(*Loc.F, Record, Idx);
6319 QualType Replacement = readType(*Loc.F, Record, Idx);
6320 return Context.getSubstTemplateTypeParmType(
6321 cast<TemplateTypeParmType>(Parm),
6322 Context.getCanonicalType(Replacement));
6323 }
6324
6325 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
6326 unsigned Idx = 0;
6327 QualType Parm = readType(*Loc.F, Record, Idx);
6328 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
6329 return Context.getSubstTemplateTypeParmPackType(
6330 cast<TemplateTypeParmType>(Parm),
6331 ArgPack);
6332 }
6333
6334 case TYPE_INJECTED_CLASS_NAME: {
6335 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
6336 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
6337 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
6338 // for AST reading, too much interdependencies.
6339 const Type *T = nullptr;
6340 for (auto *DI = D; DI; DI = DI->getPreviousDecl()) {
6341 if (const Type *Existing = DI->getTypeForDecl()) {
6342 T = Existing;
6343 break;
6344 }
6345 }
6346 if (!T) {
6347 T = new (Context, TypeAlignment) InjectedClassNameType(D, TST);
6348 for (auto *DI = D; DI; DI = DI->getPreviousDecl())
6349 DI->setTypeForDecl(T);
6350 }
6351 return QualType(T, 0);
6352 }
6353
6354 case TYPE_TEMPLATE_TYPE_PARM: {
6355 unsigned Idx = 0;
6356 unsigned Depth = Record[Idx++];
6357 unsigned Index = Record[Idx++];
6358 bool Pack = Record[Idx++];
6359 TemplateTypeParmDecl *D
6360 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
6361 return Context.getTemplateTypeParmType(Depth, Index, Pack, D);
6362 }
6363
6364 case TYPE_DEPENDENT_NAME: {
6365 unsigned Idx = 0;
6366 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6367 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6368 const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
6369 QualType Canon = readType(*Loc.F, Record, Idx);
6370 if (!Canon.isNull())
6371 Canon = Context.getCanonicalType(Canon);
6372 return Context.getDependentNameType(Keyword, NNS, Name, Canon);
6373 }
6374
6375 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
6376 unsigned Idx = 0;
6377 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6378 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6379 const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
6380 unsigned NumArgs = Record[Idx++];
6381 SmallVector<TemplateArgument, 8> Args;
6382 Args.reserve(NumArgs);
6383 while (NumArgs--)
6384 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
6385 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name,
6386 Args);
6387 }
6388
6389 case TYPE_DEPENDENT_SIZED_ARRAY: {
6390 unsigned Idx = 0;
6391
6392 // ArrayType
6393 QualType ElementType = readType(*Loc.F, Record, Idx);
6394 ArrayType::ArraySizeModifier ASM
6395 = (ArrayType::ArraySizeModifier)Record[Idx++];
6396 unsigned IndexTypeQuals = Record[Idx++];
6397
6398 // DependentSizedArrayType
6399 Expr *NumElts = ReadExpr(*Loc.F);
6400 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
6401
6402 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM,
6403 IndexTypeQuals, Brackets);
6404 }
6405
6406 case TYPE_TEMPLATE_SPECIALIZATION: {
6407 unsigned Idx = 0;
6408 bool IsDependent = Record[Idx++];
6409 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
6410 SmallVector<TemplateArgument, 8> Args;
6411 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
6412 QualType Underlying = readType(*Loc.F, Record, Idx);
6413 QualType T;
6414 if (Underlying.isNull())
6415 T = Context.getCanonicalTemplateSpecializationType(Name, Args);
6416 else
6417 T = Context.getTemplateSpecializationType(Name, Args, Underlying);
6418 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6419 return T;
6420 }
6421
6422 case TYPE_ATOMIC: {
6423 if (Record.size() != 1) {
6424 Error("Incorrect encoding of atomic type");
6425 return QualType();
6426 }
6427 QualType ValueType = readType(*Loc.F, Record, Idx);
6428 return Context.getAtomicType(ValueType);
6429 }
6430
6431 case TYPE_PIPE: {
6432 if (Record.size() != 2) {
6433 Error("Incorrect encoding of pipe type");
6434 return QualType();
6435 }
6436
6437 // Reading the pipe element type.
6438 QualType ElementType = readType(*Loc.F, Record, Idx);
6439 unsigned ReadOnly = Record[1];
6440 return Context.getPipeType(ElementType, ReadOnly);
6441 }
6442
6443 case TYPE_DEPENDENT_SIZED_VECTOR: {
6444 unsigned Idx = 0;
6445 QualType ElementType = readType(*Loc.F, Record, Idx);
6446 Expr *SizeExpr = ReadExpr(*Loc.F);
6447 SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
6448 unsigned VecKind = Record[Idx];
6449
6450 return Context.getDependentVectorType(ElementType, SizeExpr, AttrLoc,
6451 (VectorType::VectorKind)VecKind);
6452 }
6453
6454 case TYPE_DEPENDENT_SIZED_EXT_VECTOR: {
6455 unsigned Idx = 0;
6456
6457 // DependentSizedExtVectorType
6458 QualType ElementType = readType(*Loc.F, Record, Idx);
6459 Expr *SizeExpr = ReadExpr(*Loc.F);
6460 SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
6461
6462 return Context.getDependentSizedExtVectorType(ElementType, SizeExpr,
6463 AttrLoc);
6464 }
6465
6466 case TYPE_DEPENDENT_ADDRESS_SPACE: {
6467 unsigned Idx = 0;
6468
6469 // DependentAddressSpaceType
6470 QualType PointeeType = readType(*Loc.F, Record, Idx);
6471 Expr *AddrSpaceExpr = ReadExpr(*Loc.F);
6472 SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
6473
6474 return Context.getDependentAddressSpaceType(PointeeType, AddrSpaceExpr,
6475 AttrLoc);
6476 }
6477 }
6478 llvm_unreachable("Invalid TypeCode!");
6479}
6480
6481void ASTReader::readExceptionSpec(ModuleFile &ModuleFile,
6482 SmallVectorImpl<QualType> &Exceptions,
6483 FunctionProtoType::ExceptionSpecInfo &ESI,
6484 const RecordData &Record, unsigned &Idx) {
6485 ExceptionSpecificationType EST =
6486 static_cast<ExceptionSpecificationType>(Record[Idx++]);
6487 ESI.Type = EST;
6488 if (EST == EST_Dynamic) {
6489 for (unsigned I = 0, N = Record[Idx++]; I != N; ++I)
6490 Exceptions.push_back(readType(ModuleFile, Record, Idx));
6491 ESI.Exceptions = Exceptions;
6492 } else if (isComputedNoexcept(EST)) {
6493 ESI.NoexceptExpr = ReadExpr(ModuleFile);
6494 } else if (EST == EST_Uninstantiated) {
6495 ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6496 ESI.SourceTemplate = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6497 } else if (EST == EST_Unevaluated) {
6498 ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6499 }
6500}
6501
6502namespace clang {
6503
6504class TypeLocReader : public TypeLocVisitor<TypeLocReader> {
6505 ModuleFile *F;
6506 ASTReader *Reader;
6507 const ASTReader::RecordData &Record;
6508 unsigned &Idx;
6509
6510 SourceLocation ReadSourceLocation() {
6511 return Reader->ReadSourceLocation(*F, Record, Idx);
6512 }
6513
6514 TypeSourceInfo *GetTypeSourceInfo() {
6515 return Reader->GetTypeSourceInfo(*F, Record, Idx);
6516 }
6517
6518 NestedNameSpecifierLoc ReadNestedNameSpecifierLoc() {
6519 return Reader->ReadNestedNameSpecifierLoc(*F, Record, Idx);
6520 }
6521
6522 Attr *ReadAttr() {
6523 return Reader->ReadAttr(*F, Record, Idx);
6524 }
6525
6526public:
6527 TypeLocReader(ModuleFile &F, ASTReader &Reader,
6528 const ASTReader::RecordData &Record, unsigned &Idx)
6529 : F(&F), Reader(&Reader), Record(Record), Idx(Idx) {}
6530
6531 // We want compile-time assurance that we've enumerated all of
6532 // these, so unfortunately we have to declare them first, then
6533 // define them out-of-line.
6534#define ABSTRACT_TYPELOC(CLASS, PARENT)
6535#define TYPELOC(CLASS, PARENT) \
6536 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
6537#include "clang/AST/TypeLocNodes.def"
6538
6539 void VisitFunctionTypeLoc(FunctionTypeLoc);
6540 void VisitArrayTypeLoc(ArrayTypeLoc);
6541};
6542
6543} // namespace clang
6544
6545void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
6546 // nothing to do
6547}
6548
6549void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
6550 TL.setBuiltinLoc(ReadSourceLocation());
6551 if (TL.needsExtraLocalData()) {
6552 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
6553 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
6554 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
6555 TL.setModeAttr(Record[Idx++]);
6556 }
6557}
6558
6559void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
6560 TL.setNameLoc(ReadSourceLocation());
6561}
6562
6563void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
6564 TL.setStarLoc(ReadSourceLocation());
6565}
6566
6567void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
6568 // nothing to do
6569}
6570
6571void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
6572 // nothing to do
6573}
6574
6575void TypeLocReader::VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) {
6576 TL.setExpansionLoc(ReadSourceLocation());
6577}
6578
6579void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
6580 TL.setCaretLoc(ReadSourceLocation());
6581}
6582
6583void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
6584 TL.setAmpLoc(ReadSourceLocation());
6585}
6586
6587void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
6588 TL.setAmpAmpLoc(ReadSourceLocation());
6589}
6590
6591void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
6592 TL.setStarLoc(ReadSourceLocation());
6593 TL.setClassTInfo(GetTypeSourceInfo());
6594}
6595
6596void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
6597 TL.setLBracketLoc(ReadSourceLocation());
6598 TL.setRBracketLoc(ReadSourceLocation());
6599 if (Record[Idx++])
6600 TL.setSizeExpr(Reader->ReadExpr(*F));
6601 else
6602 TL.setSizeExpr(nullptr);
6603}
6604
6605void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
6606 VisitArrayTypeLoc(TL);
6607}
6608
6609void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
6610 VisitArrayTypeLoc(TL);
6611}
6612
6613void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
6614 VisitArrayTypeLoc(TL);
6615}
6616
6617void TypeLocReader::VisitDependentSizedArrayTypeLoc(
6618 DependentSizedArrayTypeLoc TL) {
6619 VisitArrayTypeLoc(TL);
6620}
6621
6622void TypeLocReader::VisitDependentAddressSpaceTypeLoc(
6623 DependentAddressSpaceTypeLoc TL) {
6624
6625 TL.setAttrNameLoc(ReadSourceLocation());
6626 SourceRange range;
6627 range.setBegin(ReadSourceLocation());
6628 range.setEnd(ReadSourceLocation());
6629 TL.setAttrOperandParensRange(range);
6630 TL.setAttrExprOperand(Reader->ReadExpr(*F));
6631}
6632
6633void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
6634 DependentSizedExtVectorTypeLoc TL) {
6635 TL.setNameLoc(ReadSourceLocation());
6636}
6637
6638void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
6639 TL.setNameLoc(ReadSourceLocation());
6640}
6641
6642void TypeLocReader::VisitDependentVectorTypeLoc(
6643 DependentVectorTypeLoc TL) {
6644 TL.setNameLoc(ReadSourceLocation());
6645}
6646
6647void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
6648 TL.setNameLoc(ReadSourceLocation());
6649}
6650
6651void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
6652 TL.setLocalRangeBegin(ReadSourceLocation());
6653 TL.setLParenLoc(ReadSourceLocation());
6654 TL.setRParenLoc(ReadSourceLocation());
6655 TL.setExceptionSpecRange(SourceRange(Reader->ReadSourceLocation(*F, Record, Idx),
6656 Reader->ReadSourceLocation(*F, Record, Idx)));
6657 TL.setLocalRangeEnd(ReadSourceLocation());
6658 for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
6659 TL.setParam(i, Reader->ReadDeclAs<ParmVarDecl>(*F, Record, Idx));
6660 }
6661}
6662
6663void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
6664 VisitFunctionTypeLoc(TL);
6665}
6666
6667void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
6668 VisitFunctionTypeLoc(TL);
6669}
6670
6671void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
6672 TL.setNameLoc(ReadSourceLocation());
6673}
6674
6675void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
6676 TL.setNameLoc(ReadSourceLocation());
6677}
6678
6679void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
6680 TL.setTypeofLoc(ReadSourceLocation());
6681 TL.setLParenLoc(ReadSourceLocation());
6682 TL.setRParenLoc(ReadSourceLocation());
6683}
6684
6685void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
6686 TL.setTypeofLoc(ReadSourceLocation());
6687 TL.setLParenLoc(ReadSourceLocation());
6688 TL.setRParenLoc(ReadSourceLocation());
6689 TL.setUnderlyingTInfo(GetTypeSourceInfo());
6690}
6691
6692void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
6693 TL.setNameLoc(ReadSourceLocation());
6694}
6695
6696void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
6697 TL.setKWLoc(ReadSourceLocation());
6698 TL.setLParenLoc(ReadSourceLocation());
6699 TL.setRParenLoc(ReadSourceLocation());
6700 TL.setUnderlyingTInfo(GetTypeSourceInfo());
6701}
6702
6703void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
6704 TL.setNameLoc(ReadSourceLocation());
6705}
6706
6707void TypeLocReader::VisitDeducedTemplateSpecializationTypeLoc(
6708 DeducedTemplateSpecializationTypeLoc TL) {
6709 TL.setTemplateNameLoc(ReadSourceLocation());
6710}
6711
6712void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
6713 TL.setNameLoc(ReadSourceLocation());
6714}
6715
6716void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
6717 TL.setNameLoc(ReadSourceLocation());
6718}
6719
6720void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
6721 TL.setAttr(ReadAttr());
6722}
6723
6724void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
6725 TL.setNameLoc(ReadSourceLocation());
6726}
6727
6728void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
6729 SubstTemplateTypeParmTypeLoc TL) {
6730 TL.setNameLoc(ReadSourceLocation());
6731}
6732
6733void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
6734 SubstTemplateTypeParmPackTypeLoc TL) {
6735 TL.setNameLoc(ReadSourceLocation());
6736}
6737
6738void TypeLocReader::VisitTemplateSpecializationTypeLoc(
6739 TemplateSpecializationTypeLoc TL) {
6740 TL.setTemplateKeywordLoc(ReadSourceLocation());
6741 TL.setTemplateNameLoc(ReadSourceLocation());
6742 TL.setLAngleLoc(ReadSourceLocation());
6743 TL.setRAngleLoc(ReadSourceLocation());
6744 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
6745 TL.setArgLocInfo(
6746 i,
6747 Reader->GetTemplateArgumentLocInfo(
6748 *F, TL.getTypePtr()->getArg(i).getKind(), Record, Idx));
6749}
6750
6751void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
6752 TL.setLParenLoc(ReadSourceLocation());
6753 TL.setRParenLoc(ReadSourceLocation());
6754}
6755
6756void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
6757 TL.setElaboratedKeywordLoc(ReadSourceLocation());
6758 TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6759}
6760
6761void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
6762 TL.setNameLoc(ReadSourceLocation());
6763}
6764
6765void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
6766 TL.setElaboratedKeywordLoc(ReadSourceLocation());
6767 TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6768 TL.setNameLoc(ReadSourceLocation());
6769}
6770
6771void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
6772 DependentTemplateSpecializationTypeLoc TL) {
6773 TL.setElaboratedKeywordLoc(ReadSourceLocation());
6774 TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6775 TL.setTemplateKeywordLoc(ReadSourceLocation());
6776 TL.setTemplateNameLoc(ReadSourceLocation());
6777 TL.setLAngleLoc(ReadSourceLocation());
6778 TL.setRAngleLoc(ReadSourceLocation());
6779 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
6780 TL.setArgLocInfo(
6781 I,
6782 Reader->GetTemplateArgumentLocInfo(
6783 *F, TL.getTypePtr()->getArg(I).getKind(), Record, Idx));
6784}
6785
6786void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
6787 TL.setEllipsisLoc(ReadSourceLocation());
6788}
6789
6790void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
6791 TL.setNameLoc(ReadSourceLocation());
6792}
6793
6794void TypeLocReader::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) {
6795 if (TL.getNumProtocols()) {
6796 TL.setProtocolLAngleLoc(ReadSourceLocation());
6797 TL.setProtocolRAngleLoc(ReadSourceLocation());
6798 }
6799 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6800 TL.setProtocolLoc(i, ReadSourceLocation());
6801}
6802
6803void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
6804 TL.setHasBaseTypeAsWritten(Record[Idx++]);
6805 TL.setTypeArgsLAngleLoc(ReadSourceLocation());
6806 TL.setTypeArgsRAngleLoc(ReadSourceLocation());
6807 for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
6808 TL.setTypeArgTInfo(i, GetTypeSourceInfo());
6809 TL.setProtocolLAngleLoc(ReadSourceLocation());
6810 TL.setProtocolRAngleLoc(ReadSourceLocation());
6811 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6812 TL.setProtocolLoc(i, ReadSourceLocation());
6813}
6814
6815void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
6816 TL.setStarLoc(ReadSourceLocation());
6817}
6818
6819void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
6820 TL.setKWLoc(ReadSourceLocation());
6821 TL.setLParenLoc(ReadSourceLocation());
6822 TL.setRParenLoc(ReadSourceLocation());
6823}
6824
6825void TypeLocReader::VisitPipeTypeLoc(PipeTypeLoc TL) {
6826 TL.setKWLoc(ReadSourceLocation());
6827}
6828
6829void ASTReader::ReadTypeLoc(ModuleFile &F, const ASTReader::RecordData &Record,
6830 unsigned &Idx, TypeLoc TL) {
6831 TypeLocReader TLR(F, *this, Record, Idx);
6832 for (; !TL.isNull(); TL = TL.getNextTypeLoc())
6833 TLR.Visit(TL);
6834}
6835
6836TypeSourceInfo *
6837ASTReader::GetTypeSourceInfo(ModuleFile &F, const ASTReader::RecordData &Record,
6838 unsigned &Idx) {
6839 QualType InfoTy = readType(F, Record, Idx);
6840 if (InfoTy.isNull())
6841 return nullptr;
6842
6843 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
6844 ReadTypeLoc(F, Record, Idx, TInfo->getTypeLoc());
6845 return TInfo;
6846}
6847
6848QualType ASTReader::GetType(TypeID ID) {
6849 assert(ContextObj && "reading type with no AST context");
6850 ASTContext &Context = *ContextObj;
6851
6852 unsigned FastQuals = ID & Qualifiers::FastMask;
6853 unsigned Index = ID >> Qualifiers::FastWidth;
6854
6855 if (Index < NUM_PREDEF_TYPE_IDS) {
6856 QualType T;
6857 switch ((PredefinedTypeIDs)Index) {
6858 case PREDEF_TYPE_NULL_ID:
6859 return QualType();
6860 case PREDEF_TYPE_VOID_ID:
6861 T = Context.VoidTy;
6862 break;
6863 case PREDEF_TYPE_BOOL_ID:
6864 T = Context.BoolTy;
6865 break;
6866 case PREDEF_TYPE_CHAR_U_ID:
6867 case PREDEF_TYPE_CHAR_S_ID:
6868 // FIXME: Check that the signedness of CharTy is correct!
6869 T = Context.CharTy;
6870 break;
6871 case PREDEF_TYPE_UCHAR_ID:
6872 T = Context.UnsignedCharTy;
6873 break;
6874 case PREDEF_TYPE_USHORT_ID:
6875 T = Context.UnsignedShortTy;
6876 break;
6877 case PREDEF_TYPE_UINT_ID:
6878 T = Context.UnsignedIntTy;
6879 break;
6880 case PREDEF_TYPE_ULONG_ID:
6881 T = Context.UnsignedLongTy;
6882 break;
6883 case PREDEF_TYPE_ULONGLONG_ID:
6884 T = Context.UnsignedLongLongTy;
6885 break;
6886 case PREDEF_TYPE_UINT128_ID:
6887 T = Context.UnsignedInt128Ty;
6888 break;
6889 case PREDEF_TYPE_UINTCAP_ID:
6890 T = Context.UnsignedIntCapTy;
6891 break;
6892 case PREDEF_TYPE_SCHAR_ID:
6893 T = Context.SignedCharTy;
6894 break;
6895 case PREDEF_TYPE_WCHAR_ID:
6896 T = Context.WCharTy;
6897 break;
6898 case PREDEF_TYPE_SHORT_ID:
6899 T = Context.ShortTy;
6900 break;
6901 case PREDEF_TYPE_INT_ID:
6902 T = Context.IntTy;
6903 break;
6904 case PREDEF_TYPE_LONG_ID:
6905 T = Context.LongTy;
6906 break;
6907 case PREDEF_TYPE_LONGLONG_ID:
6908 T = Context.LongLongTy;
6909 break;
6910 case PREDEF_TYPE_INT128_ID:
6911 T = Context.Int128Ty;
6912 break;
6913 case PREDEF_TYPE_INTCAP_ID:
6914 T = Context.IntCapTy;
6915 break;
6916 case PREDEF_TYPE_HALF_ID:
6917 T = Context.HalfTy;
6918 break;
6919 case PREDEF_TYPE_FLOAT_ID:
6920 T = Context.FloatTy;
6921 break;
6922 case PREDEF_TYPE_DOUBLE_ID:
6923 T = Context.DoubleTy;
6924 break;
6925 case PREDEF_TYPE_LONGDOUBLE_ID:
6926 T = Context.LongDoubleTy;
6927 break;
6928 case PREDEF_TYPE_SHORT_ACCUM_ID:
6929 T = Context.ShortAccumTy;
6930 break;
6931 case PREDEF_TYPE_ACCUM_ID:
6932 T = Context.AccumTy;
6933 break;
6934 case PREDEF_TYPE_LONG_ACCUM_ID:
6935 T = Context.LongAccumTy;
6936 break;
6937 case PREDEF_TYPE_USHORT_ACCUM_ID:
6938 T = Context.UnsignedShortAccumTy;
6939 break;
6940 case PREDEF_TYPE_UACCUM_ID:
6941 T = Context.UnsignedAccumTy;
6942 break;
6943 case PREDEF_TYPE_ULONG_ACCUM_ID:
6944 T = Context.UnsignedLongAccumTy;
6945 break;
6946 case PREDEF_TYPE_SHORT_FRACT_ID:
6947 T = Context.ShortFractTy;
6948 break;
6949 case PREDEF_TYPE_FRACT_ID:
6950 T = Context.FractTy;
6951 break;
6952 case PREDEF_TYPE_LONG_FRACT_ID:
6953 T = Context.LongFractTy;
6954 break;
6955 case PREDEF_TYPE_USHORT_FRACT_ID:
6956 T = Context.UnsignedShortFractTy;
6957 break;
6958 case PREDEF_TYPE_UFRACT_ID:
6959 T = Context.UnsignedFractTy;
6960 break;
6961 case PREDEF_TYPE_ULONG_FRACT_ID:
6962 T = Context.UnsignedLongFractTy;
6963 break;
6964 case PREDEF_TYPE_SAT_SHORT_ACCUM_ID:
6965 T = Context.SatShortAccumTy;
6966 break;
6967 case PREDEF_TYPE_SAT_ACCUM_ID:
6968 T = Context.SatAccumTy;
6969 break;
6970 case PREDEF_TYPE_SAT_LONG_ACCUM_ID:
6971 T = Context.SatLongAccumTy;
6972 break;
6973 case PREDEF_TYPE_SAT_USHORT_ACCUM_ID:
6974 T = Context.SatUnsignedShortAccumTy;
6975 break;
6976 case PREDEF_TYPE_SAT_UACCUM_ID:
6977 T = Context.SatUnsignedAccumTy;
6978 break;
6979 case PREDEF_TYPE_SAT_ULONG_ACCUM_ID:
6980 T = Context.SatUnsignedLongAccumTy;
6981 break;
6982 case PREDEF_TYPE_SAT_SHORT_FRACT_ID:
6983 T = Context.SatShortFractTy;
6984 break;
6985 case PREDEF_TYPE_SAT_FRACT_ID:
6986 T = Context.SatFractTy;
6987 break;
6988 case PREDEF_TYPE_SAT_LONG_FRACT_ID:
6989 T = Context.SatLongFractTy;
6990 break;
6991 case PREDEF_TYPE_SAT_USHORT_FRACT_ID:
6992 T = Context.SatUnsignedShortFractTy;
6993 break;
6994 case PREDEF_TYPE_SAT_UFRACT_ID:
6995 T = Context.SatUnsignedFractTy;
6996 break;
6997 case PREDEF_TYPE_SAT_ULONG_FRACT_ID:
6998 T = Context.SatUnsignedLongFractTy;
6999 break;
7000 case PREDEF_TYPE_FLOAT16_ID:
7001 T = Context.Float16Ty;
7002 break;
7003 case PREDEF_TYPE_FLOAT128_ID:
7004 T = Context.Float128Ty;
7005 break;
7006 case PREDEF_TYPE_OVERLOAD_ID:
7007 T = Context.OverloadTy;
7008 break;
7009 case PREDEF_TYPE_BOUND_MEMBER:
7010 T = Context.BoundMemberTy;
7011 break;
7012 case PREDEF_TYPE_PSEUDO_OBJECT:
7013 T = Context.PseudoObjectTy;
7014 break;
7015 case PREDEF_TYPE_DEPENDENT_ID:
7016 T = Context.DependentTy;
7017 break;
7018 case PREDEF_TYPE_UNKNOWN_ANY:
7019 T = Context.UnknownAnyTy;
7020 break;
7021 case PREDEF_TYPE_NULLPTR_ID:
7022 T = Context.NullPtrTy;
7023 break;
7024 case PREDEF_TYPE_CHAR8_ID:
7025 T = Context.Char8Ty;
7026 break;
7027 case PREDEF_TYPE_CHAR16_ID:
7028 T = Context.Char16Ty;
7029 break;
7030 case PREDEF_TYPE_CHAR32_ID:
7031 T = Context.Char32Ty;
7032 break;
7033 case PREDEF_TYPE_OBJC_ID:
7034 T = Context.ObjCBuiltinIdTy;
7035 break;
7036 case PREDEF_TYPE_OBJC_CLASS:
7037 T = Context.ObjCBuiltinClassTy;
7038 break;
7039 case PREDEF_TYPE_OBJC_SEL:
7040 T = Context.ObjCBuiltinSelTy;
7041 break;
7042#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
7043 case PREDEF_TYPE_##Id##_ID: \
7044 T = Context.SingletonId; \
7045 break;
7046#include "clang/Basic/OpenCLImageTypes.def"
7047#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
7048 case PREDEF_TYPE_##Id##_ID: \
7049 T = Context.Id##Ty; \
7050 break;
7051#include "clang/Basic/OpenCLExtensionTypes.def"
7052 case PREDEF_TYPE_SAMPLER_ID:
7053 T = Context.OCLSamplerTy;
7054 break;
7055 case PREDEF_TYPE_EVENT_ID:
7056 T = Context.OCLEventTy;
7057 break;
7058 case PREDEF_TYPE_CLK_EVENT_ID:
7059 T = Context.OCLClkEventTy;
7060 break;
7061 case PREDEF_TYPE_QUEUE_ID:
7062 T = Context.OCLQueueTy;
7063 break;
7064 case PREDEF_TYPE_RESERVE_ID_ID:
7065 T = Context.OCLReserveIDTy;
7066 break;
7067 case PREDEF_TYPE_AUTO_DEDUCT:
7068 T = Context.getAutoDeductType();
7069 break;
7070 case PREDEF_TYPE_AUTO_RREF_DEDUCT:
7071 T = Context.getAutoRRefDeductType();
7072 break;
7073 case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
7074 T = Context.ARCUnbridgedCastTy;
7075 break;
7076 case PREDEF_TYPE_BUILTIN_FN:
7077 T = Context.BuiltinFnTy;
7078 break;
7079 case PREDEF_TYPE_OMP_ARRAY_SECTION:
7080 T = Context.OMPArraySectionTy;
7081 break;
7082 }
7083
7084 assert(!T.isNull() && "Unknown predefined type");
7085 return T.withFastQualifiers(FastQuals);
7086 }
7087
7088 Index -= NUM_PREDEF_TYPE_IDS;
7089 assert(Index < TypesLoaded.size() && "Type index out-of-range");
7090 if (TypesLoaded[Index].isNull()) {
7091 TypesLoaded[Index] = readTypeRecord(Index);
7092 if (TypesLoaded[Index].isNull())
7093 return QualType();
7094
7095 TypesLoaded[Index]->setFromAST();
7096 if (DeserializationListener)
7097 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
7098 TypesLoaded[Index]);
7099 }
7100
7101 return TypesLoaded[Index].withFastQualifiers(FastQuals);
7102}
7103
7104QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
7105 return GetType(getGlobalTypeID(F, LocalID));
7106}
7107
7108serialization::TypeID
7109ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
7110 unsigned FastQuals = LocalID & Qualifiers::FastMask;
7111 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
7112
7113 if (LocalIndex < NUM_PREDEF_TYPE_IDS)
7114 return LocalID;
7115
7116 if (!F.ModuleOffsetMap.empty())
7117 ReadModuleOffsetMap(F);
7118
7119 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7120 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
7121 assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
7122
7123 unsigned GlobalIndex = LocalIndex + I->second;
7124 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
7125}
7126
7127TemplateArgumentLocInfo
7128ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F,
7129 TemplateArgument::ArgKind Kind,
7130 const RecordData &Record,
7131 unsigned &Index) {
7132 switch (Kind) {
7133 case TemplateArgument::Expression:
7134 return ReadExpr(F);
7135 case TemplateArgument::Type:
7136 return GetTypeSourceInfo(F, Record, Index);
7137 case TemplateArgument::Template: {
7138 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
7139 Index);
7140 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
7141 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
7142 SourceLocation());
7143 }
7144 case TemplateArgument::TemplateExpansion: {
7145 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
7146 Index);
7147 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
7148 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
7149 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
7150 EllipsisLoc);
7151 }
7152 case TemplateArgument::Null:
7153 case TemplateArgument::Integral:
7154 case TemplateArgument::Declaration:
7155 case TemplateArgument::NullPtr:
7156 case TemplateArgument::Pack:
7157 // FIXME: Is this right?
7158 return TemplateArgumentLocInfo();
7159 }
7160 llvm_unreachable("unexpected template argument loc");
7161}
7162
7163TemplateArgumentLoc
7164ASTReader::ReadTemplateArgumentLoc(ModuleFile &F,
7165 const RecordData &Record, unsigned &Index) {
7166 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
7167
7168 if (Arg.getKind() == TemplateArgument::Expression) {
7169 if (Record[Index++]) // bool InfoHasSameExpr.
7170 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
7171 }
7172 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
7173 Record, Index));
7174}
7175
7176const ASTTemplateArgumentListInfo*
7177ASTReader::ReadASTTemplateArgumentListInfo(ModuleFile &F,
7178 const RecordData &Record,
7179 unsigned &Index) {
7180 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Index);
7181 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Index);
7182 unsigned NumArgsAsWritten = Record[Index++];
7183 TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
7184 for (unsigned i = 0; i != NumArgsAsWritten; ++i)
7185 TemplArgsInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Index));
7186 return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo);
7187}
7188
7189Decl *ASTReader::GetExternalDecl(uint32_t ID) {
7190 return GetDecl(ID);
7191}
7192
7193void ASTReader::CompleteRedeclChain(const Decl *D) {
7194 if (NumCurrentElementsDeserializing) {
7195 // We arrange to not care about the complete redeclaration chain while we're
7196 // deserializing. Just remember that the AST has marked this one as complete
7197 // but that it's not actually complete yet, so we know we still need to
7198 // complete it later.
7199 PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D));
7200 return;
7201 }
7202
7203 const DeclContext *DC = D->getDeclContext()->getRedeclContext();
7204
7205 // If this is a named declaration, complete it by looking it up
7206 // within its context.
7207 //
7208 // FIXME: Merging a function definition should merge
7209 // all mergeable entities within it.
7210 if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC) ||
7211 isa<CXXRecordDecl>(DC) || isa<EnumDecl>(DC)) {
7212 if (DeclarationName Name = cast<NamedDecl>(D)->getDeclName()) {
7213 if (!getContext().getLangOpts().CPlusPlus &&
7214 isa<TranslationUnitDecl>(DC)) {
7215 // Outside of C++, we don't have a lookup table for the TU, so update
7216 // the identifier instead. (For C++ modules, we don't store decls
7217 // in the serialized identifier table, so we do the lookup in the TU.)
7218 auto *II = Name.getAsIdentifierInfo();
7219 assert(II && "non-identifier name in C?");
7220 if (II->isOutOfDate())
7221 updateOutOfDateIdentifier(*II);
7222 } else
7223 DC->lookup(Name);
7224 } else if (needsAnonymousDeclarationNumber(cast<NamedDecl>(D))) {
7225 // Find all declarations of this kind from the relevant context.
7226 for (auto *DCDecl : cast<Decl>(D->getLexicalDeclContext())->redecls()) {
7227 auto *DC = cast<DeclContext>(DCDecl);
7228 SmallVector<Decl*, 8> Decls;
7229 FindExternalLexicalDecls(
7230 DC, [&](Decl::Kind K) { return K == D->getKind(); }, Decls);
7231 }
7232 }
7233 }
7234
7235 if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
7236 CTSD->getSpecializedTemplate()->LoadLazySpecializations();
7237 if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
7238 VTSD->getSpecializedTemplate()->LoadLazySpecializations();
7239 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
7240 if (auto *Template = FD->getPrimaryTemplate())
7241 Template->LoadLazySpecializations();
7242 }
7243}
7244
7245CXXCtorInitializer **
7246ASTReader::GetExternalCXXCtorInitializers(uint64_t Offset) {
7247 RecordLocation Loc = getLocalBitOffset(Offset);
7248 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7249 SavedStreamPosition SavedPosition(Cursor);
7250 Cursor.JumpToBit(Loc.Offset);
7251 ReadingKindTracker ReadingKind(Read_Decl, *this);
7252
7253 RecordData Record;
7254 unsigned Code = Cursor.ReadCode();
7255 unsigned RecCode = Cursor.readRecord(Code, Record);
7256 if (RecCode != DECL_CXX_CTOR_INITIALIZERS) {
7257 Error("malformed AST file: missing C++ ctor initializers");
7258 return nullptr;
7259 }
7260
7261 unsigned Idx = 0;
7262 return ReadCXXCtorInitializers(*Loc.F, Record, Idx);
7263}
7264
7265CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
7266 assert(ContextObj && "reading base specifiers with no AST context");
7267 ASTContext &Context = *ContextObj;
7268
7269 RecordLocation Loc = getLocalBitOffset(Offset);
7270 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7271 SavedStreamPosition SavedPosition(Cursor);
7272 Cursor.JumpToBit(Loc.Offset);
7273 ReadingKindTracker ReadingKind(Read_Decl, *this);
7274 RecordData Record;
7275 unsigned Code = Cursor.ReadCode();
7276 unsigned RecCode = Cursor.readRecord(Code, Record);
7277 if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
7278 Error("malformed AST file: missing C++ base specifiers");
7279 return nullptr;
7280 }
7281
7282 unsigned Idx = 0;
7283 unsigned NumBases = Record[Idx++];
7284 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
7285 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
7286 for (unsigned I = 0; I != NumBases; ++I)
7287 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
7288 return Bases;
7289}
7290
7291serialization::DeclID
7292ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const {
7293 if (LocalID < NUM_PREDEF_DECL_IDS)
7294 return LocalID;
7295
7296 if (!F.ModuleOffsetMap.empty())
7297 ReadModuleOffsetMap(F);
7298
7299 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7300 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
7301 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
7302
7303 return LocalID + I->second;
7304}
7305
7306bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID,
7307 ModuleFile &M) const {
7308 // Predefined decls aren't from any module.
7309 if (ID < NUM_PREDEF_DECL_IDS)
7310 return false;
7311
7312 return ID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
7313 ID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls;
7314}
7315
7316ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) {
7317 if (!D->isFromASTFile())
7318 return nullptr;
7319 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
7320 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
7321 return I->second;
7322}
7323
7324SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) {
7325 if (ID < NUM_PREDEF_DECL_IDS)
7326 return SourceLocation();
7327
7328 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7329
7330 if (Index > DeclsLoaded.size()) {
7331 Error("declaration ID out-of-range for AST file");
7332 return SourceLocation();
7333 }
7334
7335 if (Decl *D = DeclsLoaded[Index])
7336 return D->getLocation();
7337
7338 SourceLocation Loc;
7339 DeclCursorForID(ID, Loc);
7340 return Loc;
7341}
7342
7343static Decl *getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID) {
7344 switch (ID) {
7345 case PREDEF_DECL_NULL_ID:
7346 return nullptr;
7347
7348 case PREDEF_DECL_TRANSLATION_UNIT_ID:
7349 return Context.getTranslationUnitDecl();
7350
7351 case PREDEF_DECL_OBJC_ID_ID:
7352 return Context.getObjCIdDecl();
7353
7354 case PREDEF_DECL_OBJC_SEL_ID:
7355 return Context.getObjCSelDecl();
7356
7357 case PREDEF_DECL_OBJC_CLASS_ID:
7358 return Context.getObjCClassDecl();
7359
7360 case PREDEF_DECL_OBJC_PROTOCOL_ID:
7361 return Context.getObjCProtocolDecl();
7362
7363 case PREDEF_DECL_INT_128_ID:
7364 return Context.getInt128Decl();
7365
7366 case PREDEF_DECL_UNSIGNED_INT_128_ID:
7367 return Context.getUInt128Decl();
7368
7369 case PREDEF_DECL_OBJC_INSTANCETYPE_ID:
7370 return Context.getObjCInstanceTypeDecl();
7371
7372 case PREDEF_DECL_BUILTIN_VA_LIST_ID:
7373 return Context.getBuiltinVaListDecl();
7374
7375 case PREDEF_DECL_VA_LIST_TAG:
7376 return Context.getVaListTagDecl();
7377
7378 case PREDEF_DECL_BUILTIN_MS_VA_LIST_ID:
7379 return Context.getBuiltinMSVaListDecl();
7380
7381 case PREDEF_DECL_EXTERN_C_CONTEXT_ID:
7382 return Context.getExternCContextDecl();
7383
7384 case PREDEF_DECL_MAKE_INTEGER_SEQ_ID:
7385 return Context.getMakeIntegerSeqDecl();
7386
7387 case PREDEF_DECL_CF_CONSTANT_STRING_ID:
7388 return Context.getCFConstantStringDecl();
7389
7390 case PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID:
7391 return Context.getCFConstantStringTagDecl();
7392
7393 case PREDEF_DECL_TYPE_PACK_ELEMENT_ID:
7394 return Context.getTypePackElementDecl();
7395 }
7396 llvm_unreachable("PredefinedDeclIDs unknown enum value");
7397}
7398
7399Decl *ASTReader::GetExistingDecl(DeclID ID) {
7400 assert(ContextObj && "reading decl with no AST context");
7401 if (ID < NUM_PREDEF_DECL_IDS) {
7402 Decl *D = getPredefinedDecl(*ContextObj, (PredefinedDeclIDs)ID);
7403 if (D) {
7404 // Track that we have merged the declaration with ID \p ID into the
7405 // pre-existing predefined declaration \p D.
7406 auto &Merged = KeyDecls[D->getCanonicalDecl()];
7407 if (Merged.empty())
7408 Merged.push_back(ID);
7409 }
7410 return D;
7411 }
7412
7413 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7414
7415 if (Index >= DeclsLoaded.size()) {
7416 assert(0 && "declaration ID out-of-range for AST file");
7417 Error("declaration ID out-of-range for AST file");
7418 return nullptr;
7419 }
7420
7421 return DeclsLoaded[Index];
7422}
7423
7424Decl *ASTReader::GetDecl(DeclID ID) {
7425 if (ID < NUM_PREDEF_DECL_IDS)
7426 return GetExistingDecl(ID);
7427
7428 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7429
7430 if (Index >= DeclsLoaded.size()) {
7431 assert(0 && "declaration ID out-of-range for AST file");
7432 Error("declaration ID out-of-range for AST file");
7433 return nullptr;
7434 }
7435
7436 if (!DeclsLoaded[Index]) {
7437 ReadDeclRecord(ID);
7438 if (DeserializationListener)
7439 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
7440 }
7441
7442 return DeclsLoaded[Index];
7443}
7444
7445DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M,
7446 DeclID GlobalID) {
7447 if (GlobalID < NUM_PREDEF_DECL_IDS)
7448 return GlobalID;
7449
7450 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
7451 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
7452 ModuleFile *Owner = I->second;
7453
7454 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
7455 = M.GlobalToLocalDeclIDs.find(Owner);
7456 if (Pos == M.GlobalToLocalDeclIDs.end())
7457 return 0;
7458
7459 return GlobalID - Owner->BaseDeclID + Pos->second;
7460}
7461
7462serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F,
7463 const RecordData &Record,
7464 unsigned &Idx) {
7465 if (Idx >= Record.size()) {
7466 Error("Corrupted AST file");
7467 return 0;
7468 }
7469
7470 return getGlobalDeclID(F, Record[Idx++]);
7471}
7472
7473/// Resolve the offset of a statement into a statement.
7474///
7475/// This operation will read a new statement from the external
7476/// source each time it is called, and is meant to be used via a
7477/// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
7478Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
7479 // Switch case IDs are per Decl.
7480 ClearSwitchCaseIDs();
7481
7482 // Offset here is a global offset across the entire chain.
7483 RecordLocation Loc = getLocalBitOffset(Offset);
7484 Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
7485 assert(NumCurrentElementsDeserializing == 0 &&
7486 "should not be called while already deserializing");
7487 Deserializing D(this);
7488 return ReadStmtFromStream(*Loc.F);
7489}
7490
7491void ASTReader::FindExternalLexicalDecls(
7492 const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
7493 SmallVectorImpl<Decl *> &Decls) {
7494 bool PredefsVisited[NUM_PREDEF_DECL_IDS] = {};
7495
7496 auto Visit = [&] (ModuleFile *M, LexicalContents LexicalDecls) {
7497 assert(LexicalDecls.size() % 2 == 0 && "expected an even number of entries");
7498 for (int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
7499 auto K = (Decl::Kind)+LexicalDecls[I];
7500 if (!IsKindWeWant(K))
7501 continue;
7502
7503 auto ID = (serialization::DeclID)+LexicalDecls[I + 1];
7504
7505 // Don't add predefined declarations to the lexical context more
7506 // than once.
7507 if (ID < NUM_PREDEF_DECL_IDS) {
7508 if (PredefsVisited[ID])
7509 continue;
7510
7511 PredefsVisited[ID] = true;
7512 }
7513
7514 if (Decl *D = GetLocalDecl(*M, ID)) {
7515 assert(D->getKind() == K && "wrong kind for lexical decl");
7516 if (!DC->isDeclInLexicalTraversal(D))
7517 Decls.push_back(D);
7518 }
7519 }
7520 };
7521
7522 if (isa<TranslationUnitDecl>(DC)) {
7523 for (auto Lexical : TULexicalDecls)
7524 Visit(Lexical.first, Lexical.second);
7525 } else {
7526 auto I = LexicalDecls.find(DC);
7527 if (I != LexicalDecls.end())
7528 Visit(I->second.first, I->second.second);
7529 }
7530
7531 ++NumLexicalDeclContextsRead;
7532}
7533
7534namespace {
7535
7536class DeclIDComp {
7537 ASTReader &Reader;
7538 ModuleFile &Mod;
7539
7540public:
7541 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
7542
7543 bool operator()(LocalDeclID L, LocalDeclID R) const {
7544 SourceLocation LHS = getLocation(L);
7545 SourceLocation RHS = getLocation(R);
7546 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7547 }
7548
7549 bool operator()(SourceLocation LHS, LocalDeclID R) const {
7550 SourceLocation RHS = getLocation(R);
7551 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7552 }
7553
7554 bool operator()(LocalDeclID L, SourceLocation RHS) const {
7555 SourceLocation LHS = getLocation(L);
7556 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7557 }
7558
7559 SourceLocation getLocation(LocalDeclID ID) const {
7560 return Reader.getSourceManager().getFileLoc(
7561 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
7562 }
7563};
7564
7565} // namespace
7566
7567void ASTReader::FindFileRegionDecls(FileID File,
7568 unsigned Offset, unsigned Length,
7569 SmallVectorImpl<Decl *> &Decls) {
7570 SourceManager &SM = getSourceManager();
7571
7572 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
7573 if (I == FileDeclIDs.end())
7574 return;
7575
7576 FileDeclsInfo &DInfo = I->second;
7577 if (DInfo.Decls.empty())
7578 return;
7579
7580 SourceLocation
7581 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
7582 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
7583
7584 DeclIDComp DIDComp(*this, *DInfo.Mod);
7585 ArrayRef<serialization::LocalDeclID>::iterator
7586 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
7587 BeginLoc, DIDComp);
7588 if (BeginIt != DInfo.Decls.begin())
7589 --BeginIt;
7590
7591 // If we are pointing at a top-level decl inside an objc container, we need
7592 // to backtrack until we find it otherwise we will fail to report that the
7593 // region overlaps with an objc container.
7594 while (BeginIt != DInfo.Decls.begin() &&
7595 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
7596 ->isTopLevelDeclInObjCContainer())
7597 --BeginIt;
7598
7599 ArrayRef<serialization::LocalDeclID>::iterator
7600 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
7601 EndLoc, DIDComp);
7602 if (EndIt != DInfo.Decls.end())
7603 ++EndIt;
7604
7605 for (ArrayRef<serialization::LocalDeclID>::iterator
7606 DIt = BeginIt; DIt != EndIt; ++DIt)
7607 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
7608}
7609
7610bool
7611ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
7612 DeclarationName Name) {
7613 assert(DC->hasExternalVisibleStorage() && DC == DC->getPrimaryContext() &&
7614 "DeclContext has no visible decls in storage");
7615 if (!Name)
7616 return false;
7617
7618 auto It = Lookups.find(DC);
7619 if (It == Lookups.end())
7620 return false;
7621
7622 Deserializing LookupResults(this);
7623
7624 // Load the list of declarations.
7625 SmallVector<NamedDecl *, 64> Decls;
7626 for (DeclID ID : It->second.Table.find(Name)) {
7627 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7628 if (ND->getDeclName() == Name)
7629 Decls.push_back(ND);
7630 }
7631
7632 ++NumVisibleDeclContextsRead;
7633 SetExternalVisibleDeclsForName(DC, Name, Decls);
7634 return !Decls.empty();
7635}
7636
7637void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) {
7638 if (!DC->hasExternalVisibleStorage())
7639 return;
7640
7641 auto It = Lookups.find(DC);
7642 assert(It != Lookups.end() &&
7643 "have external visible storage but no lookup tables");
7644
7645 DeclsMap Decls;
7646
7647 for (DeclID ID : It->second.Table.findAll()) {
7648 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7649 Decls[ND->getDeclName()].push_back(ND);
7650 }
7651
7652 ++NumVisibleDeclContextsRead;
7653
7654 for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
7655 SetExternalVisibleDeclsForName(DC, I->first, I->second);
7656 }
7657 const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false);
7658}
7659
7660const serialization::reader::DeclContextLookupTable *
7661ASTReader::getLoadedLookupTables(DeclContext *Primary) const {
7662 auto I = Lookups.find(Primary);
7663 return I == Lookups.end() ? nullptr : &I->second;
7664}
7665
7666/// Under non-PCH compilation the consumer receives the objc methods
7667/// before receiving the implementation, and codegen depends on this.
7668/// We simulate this by deserializing and passing to consumer the methods of the
7669/// implementation before passing the deserialized implementation decl.
7670static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD,
7671 ASTConsumer *Consumer) {
7672 assert(ImplD && Consumer);
7673
7674 for (auto *I : ImplD->methods())
7675 Consumer->HandleInterestingDecl(DeclGroupRef(I));
7676
7677 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
7678}
7679
7680void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
7681 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
7682 PassObjCImplDeclToConsumer(ImplD, Consumer);
7683 else
7684 Consumer->HandleInterestingDecl(DeclGroupRef(D));
7685}
7686
7687void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
7688 this->Consumer = Consumer;
7689
7690 if (Consumer)
7691 PassInterestingDeclsToConsumer();
7692
7693 if (DeserializationListener)
7694 DeserializationListener->ReaderInitialized(this);
7695}
7696
7697void ASTReader::PrintStats() {
7698 std::fprintf(stderr, "*** AST File Statistics:\n");
7699
7700 unsigned NumTypesLoaded
7701 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
7702 QualType());
7703 unsigned NumDeclsLoaded
7704 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
7705 (Decl *)nullptr);
7706 unsigned NumIdentifiersLoaded
7707 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
7708 IdentifiersLoaded.end(),
7709 (IdentifierInfo *)nullptr);
7710 unsigned NumMacrosLoaded
7711 = MacrosLoaded.size() - std::count(MacrosLoaded.begin(),
7712 MacrosLoaded.end(),
7713 (MacroInfo *)nullptr);
7714 unsigned NumSelectorsLoaded
7715 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
7716 SelectorsLoaded.end(),
7717 Selector());
7718
7719 if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
7720 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
7721 NumSLocEntriesRead, TotalNumSLocEntries,
7722 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
7723 if (!TypesLoaded.empty())
7724 std::fprintf(stderr, " %u/%u types read (%f%%)\n",
7725 NumTypesLoaded, (unsigned)TypesLoaded.size(),
7726 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
7727 if (!DeclsLoaded.empty())
7728 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
7729 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
7730 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
7731 if (!IdentifiersLoaded.empty())
7732 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
7733 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
7734 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
7735 if (!MacrosLoaded.empty())
7736 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
7737 NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
7738 ((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
7739 if (!SelectorsLoaded.empty())
7740 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
7741 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
7742 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
7743 if (TotalNumStatements)
7744 std::fprintf(stderr, " %u/%u statements read (%f%%)\n",
7745 NumStatementsRead, TotalNumStatements,
7746 ((float)NumStatementsRead/TotalNumStatements * 100));
7747 if (TotalNumMacros)
7748 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
7749 NumMacrosRead, TotalNumMacros,
7750 ((float)NumMacrosRead/TotalNumMacros * 100));
7751 if (TotalLexicalDeclContexts)
7752 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n",
7753 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
7754 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
7755 * 100));
7756 if (TotalVisibleDeclContexts)
7757 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n",
7758 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
7759 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
7760 * 100));
7761 if (TotalNumMethodPoolEntries)
7762 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
7763 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
7764 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
7765 * 100));
7766 if (NumMethodPoolLookups)
7767 std::fprintf(stderr, " %u/%u method pool lookups succeeded (%f%%)\n",
7768 NumMethodPoolHits, NumMethodPoolLookups,
7769 ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
7770 if (NumMethodPoolTableLookups)
7771 std::fprintf(stderr, " %u/%u method pool table lookups succeeded (%f%%)\n",
7772 NumMethodPoolTableHits, NumMethodPoolTableLookups,
7773 ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups
7774 * 100.0));
7775 if (NumIdentifierLookupHits)
7776 std::fprintf(stderr,
7777 " %u / %u identifier table lookups succeeded (%f%%)\n",
7778 NumIdentifierLookupHits, NumIdentifierLookups,
7779 (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
7780
7781 if (GlobalIndex) {
7782 std::fprintf(stderr, "\n");
7783 GlobalIndex->printStats();
7784 }
7785
7786 std::fprintf(stderr, "\n");
7787 dump();
7788 std::fprintf(stderr, "\n");
7789}
7790
7791template<typename Key, typename ModuleFile, unsigned InitialCapacity>
7792LLVM_DUMP_METHOD static void
7793dumpModuleIDMap(StringRef Name,
7794 const ContinuousRangeMap<Key, ModuleFile *,
7795 InitialCapacity> &Map) {
7796 if (Map.begin() == Map.end())
7797 return;
7798
7799 using MapType = ContinuousRangeMap<Key, ModuleFile *, InitialCapacity>;
7800
7801 llvm::errs() << Name << ":\n";
7802 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
7803 I != IEnd; ++I) {
7804 llvm::errs() << " " << I->first << " -> " << I->second->FileName
7805 << "\n";
7806 }
7807}
7808
7809LLVM_DUMP_METHOD void ASTReader::dump() {
7810 llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
7811 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
7812 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
7813 dumpModuleIDMap("Global type map", GlobalTypeMap);
7814 dumpModuleIDMap("Global declaration map", GlobalDeclMap);
7815 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
7816 dumpModuleIDMap("Global macro map", GlobalMacroMap);
7817 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
7818 dumpModuleIDMap("Global selector map", GlobalSelectorMap);
7819 dumpModuleIDMap("Global preprocessed entity map",
7820 GlobalPreprocessedEntityMap);
7821
7822 llvm::errs() << "\n*** PCH/Modules Loaded:";
7823 for (ModuleFile &M : ModuleMgr)
7824 M.dump();
7825}
7826
7827/// Return the amount of memory used by memory buffers, breaking down
7828/// by heap-backed versus mmap'ed memory.
7829void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
7830 for (ModuleFile &I : ModuleMgr) {
7831 if (llvm::MemoryBuffer *buf = I.Buffer) {
7832 size_t bytes = buf->getBufferSize();
7833 switch (buf->getBufferKind()) {
7834 case llvm::MemoryBuffer::MemoryBuffer_Malloc:
7835 sizes.malloc_bytes += bytes;
7836 break;
7837 case llvm::MemoryBuffer::MemoryBuffer_MMap:
7838 sizes.mmap_bytes += bytes;
7839 break;
7840 }
7841 }
7842 }
7843}
7844
7845void ASTReader::InitializeSema(Sema &S) {
7846 SemaObj = &S;
7847 S.addExternalSource(this);
7848
7849 // Makes sure any declarations that were deserialized "too early"
7850 // still get added to the identifier's declaration chains.
7851 for (uint64_t ID : PreloadedDeclIDs) {
7852 NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
7853 pushExternalDeclIntoScope(D, D->getDeclName());
7854 }
7855 PreloadedDeclIDs.clear();
7856
7857 // FIXME: What happens if these are changed by a module import?
7858 if (!FPPragmaOptions.empty()) {
7859 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
7860 SemaObj->FPFeatures = FPOptions(FPPragmaOptions[0]);
7861 }
7862
7863 SemaObj->OpenCLFeatures.copy(OpenCLExtensions);
7864 SemaObj->OpenCLTypeExtMap = OpenCLTypeExtMap;
7865 SemaObj->OpenCLDeclExtMap = OpenCLDeclExtMap;
7866
7867 UpdateSema();
7868}
7869
7870void ASTReader::UpdateSema() {
7871 assert(SemaObj && "no Sema to update");
7872
7873 // Load the offsets of the declarations that Sema references.
7874 // They will be lazily deserialized when needed.
7875 if (!SemaDeclRefs.empty()) {
7876 assert(SemaDeclRefs.size() % 3 == 0);
7877 for (unsigned I = 0; I != SemaDeclRefs.size(); I += 3) {
7878 if (!SemaObj->StdNamespace)
7879 SemaObj->StdNamespace = SemaDeclRefs[I];
7880 if (!SemaObj->StdBadAlloc)
7881 SemaObj->StdBadAlloc = SemaDeclRefs[I+1];
7882 if (!SemaObj->StdAlignValT)
7883 SemaObj->StdAlignValT = SemaDeclRefs[I+2];
7884 }
7885 SemaDeclRefs.clear();
7886 }
7887
7888 // Update the state of pragmas. Use the same API as if we had encountered the
7889 // pragma in the source.
7890 if(OptimizeOffPragmaLocation.isValid())
7891 SemaObj->ActOnPragmaOptimize(/* IsOn = */ false, OptimizeOffPragmaLocation);
7892 if (PragmaMSStructState != -1)
7893 SemaObj->ActOnPragmaMSStruct((PragmaMSStructKind)PragmaMSStructState);
7894 if (PointersToMembersPragmaLocation.isValid()) {
7895 SemaObj->ActOnPragmaMSPointersToMembers(
7896 (LangOptions::PragmaMSPointersToMembersKind)
7897 PragmaMSPointersToMembersState,
7898 PointersToMembersPragmaLocation);
7899 }
7900 SemaObj->ForceCUDAHostDeviceDepth = ForceCUDAHostDeviceDepth;
7901
7902 if (PragmaPackCurrentValue) {
7903 // The bottom of the stack might have a default value. It must be adjusted
7904 // to the current value to ensure that the packing state is preserved after
7905 // popping entries that were included/imported from a PCH/module.
7906 bool DropFirst = false;
7907 if (!PragmaPackStack.empty() &&
7908 PragmaPackStack.front().Location.isInvalid()) {
7909 assert(PragmaPackStack.front().Value == SemaObj->PackStack.DefaultValue &&
7910 "Expected a default alignment value");
7911 SemaObj->PackStack.Stack.emplace_back(
7912 PragmaPackStack.front().SlotLabel, SemaObj->PackStack.CurrentValue,
7913 SemaObj->PackStack.CurrentPragmaLocation,
7914 PragmaPackStack.front().PushLocation);
7915 DropFirst = true;
7916 }
7917 for (const auto &Entry :
7918 llvm::makeArrayRef(PragmaPackStack).drop_front(DropFirst ? 1 : 0))
7919 SemaObj->PackStack.Stack.emplace_back(Entry.SlotLabel, Entry.Value,
7920 Entry.Location, Entry.PushLocation);
7921 if (PragmaPackCurrentLocation.isInvalid()) {
7922 assert(*PragmaPackCurrentValue == SemaObj->PackStack.DefaultValue &&
7923 "Expected a default alignment value");
7924 // Keep the current values.
7925 } else {
7926 SemaObj->PackStack.CurrentValue = *PragmaPackCurrentValue;
7927 SemaObj->PackStack.CurrentPragmaLocation = PragmaPackCurrentLocation;
7928 }
7929 }
7930}
7931
7932IdentifierInfo *ASTReader::get(StringRef Name) {
7933 // Note that we are loading an identifier.
7934 Deserializing AnIdentifier(this);
7935
7936 IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0,
7937 NumIdentifierLookups,
7938 NumIdentifierLookupHits);
7939
7940 // We don't need to do identifier table lookups in C++ modules (we preload
7941 // all interesting declarations, and don't need to use the scope for name
7942 // lookups). Perform the lookup in PCH files, though, since we don't build
7943 // a complete initial identifier table if we're carrying on from a PCH.
7944 if (PP.getLangOpts().CPlusPlus) {
7945 for (auto F : ModuleMgr.pch_modules())
7946 if (Visitor(*F))
7947 break;
7948 } else {
7949 // If there is a global index, look there first to determine which modules
7950 // provably do not have any results for this identifier.
7951 GlobalModuleIndex::HitSet Hits;
7952 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
7953 if (!loadGlobalIndex()) {
7954 if (GlobalIndex->lookupIdentifier(Name, Hits)) {
7955 HitsPtr = &Hits;
7956 }
7957 }
7958
7959 ModuleMgr.visit(Visitor, HitsPtr);
7960 }
7961
7962 IdentifierInfo *II = Visitor.getIdentifierInfo();
7963 markIdentifierUpToDate(II);
7964 return II;
7965}
7966
7967namespace clang {
7968
7969 /// An identifier-lookup iterator that enumerates all of the
7970 /// identifiers stored within a set of AST files.
7971 class ASTIdentifierIterator : public IdentifierIterator {
7972 /// The AST reader whose identifiers are being enumerated.
7973 const ASTReader &Reader;
7974
7975 /// The current index into the chain of AST files stored in
7976 /// the AST reader.
7977 unsigned Index;
7978
7979 /// The current position within the identifier lookup table
7980 /// of the current AST file.
7981 ASTIdentifierLookupTable::key_iterator Current;
7982
7983 /// The end position within the identifier lookup table of
7984 /// the current AST file.
7985 ASTIdentifierLookupTable::key_iterator End;
7986
7987 /// Whether to skip any modules in the ASTReader.
7988 bool SkipModules;
7989
7990 public:
7991 explicit ASTIdentifierIterator(const ASTReader &Reader,
7992 bool SkipModules = false);
7993
7994 StringRef Next() override;
7995 };
7996
7997} // namespace clang
7998
7999ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader,
8000 bool SkipModules)
8001 : Reader(Reader), Index(Reader.ModuleMgr.size()), SkipModules(SkipModules) {
8002}
8003
8004StringRef ASTIdentifierIterator::Next() {
8005 while (Current == End) {
8006 // If we have exhausted all of our AST files, we're done.
8007 if (Index == 0)
8008 return StringRef();
8009
8010 --Index;
8011 ModuleFile &F = Reader.ModuleMgr[Index];
8012 if (SkipModules && F.isModule())
8013 continue;
8014
8015 ASTIdentifierLookupTable *IdTable =
8016 (ASTIdentifierLookupTable *)F.IdentifierLookupTable;
8017 Current = IdTable->key_begin();
8018 End = IdTable->key_end();
8019 }
8020
8021 // We have any identifiers remaining in the current AST file; return
8022 // the next one.
8023 StringRef Result = *Current;
8024 ++Current;
8025 return Result;
8026}
8027
8028namespace {
8029
8030/// A utility for appending two IdentifierIterators.
8031class ChainedIdentifierIterator : public IdentifierIterator {
8032 std::unique_ptr<IdentifierIterator> Current;
8033 std::unique_ptr<IdentifierIterator> Queued;
8034
8035public:
8036 ChainedIdentifierIterator(std::unique_ptr<IdentifierIterator> First,
8037 std::unique_ptr<IdentifierIterator> Second)
8038 : Current(std::move(First)), Queued(std::move(Second)) {}
8039
8040 StringRef Next() override {
8041 if (!Current)
8042 return StringRef();
8043
8044 StringRef result = Current->Next();
8045 if (!result.empty())
8046 return result;
8047
8048 // Try the queued iterator, which may itself be empty.
8049 Current.reset();
8050 std::swap(Current, Queued);
8051 return Next();
8052 }
8053};
8054
8055} // namespace
8056
8057IdentifierIterator *ASTReader::getIdentifiers() {
8058 if (!loadGlobalIndex()) {
8059 std::unique_ptr<IdentifierIterator> ReaderIter(
8060 new ASTIdentifierIterator(*this, /*SkipModules=*/true));
8061 std::unique_ptr<IdentifierIterator> ModulesIter(
8062 GlobalIndex->createIdentifierIterator());
8063 return new ChainedIdentifierIterator(std::move(ReaderIter),
8064 std::move(ModulesIter));
8065 }
8066
8067 return new ASTIdentifierIterator(*this);
8068}
8069
8070namespace clang {
8071namespace serialization {
8072
8073 class ReadMethodPoolVisitor {
8074 ASTReader &Reader;
8075 Selector Sel;
8076 unsigned PriorGeneration;
8077 unsigned InstanceBits = 0;
8078 unsigned FactoryBits = 0;
8079 bool InstanceHasMoreThanOneDecl = false;
8080 bool FactoryHasMoreThanOneDecl = false;
8081 SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
8082 SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
8083
8084 public:
8085 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel,
8086 unsigned PriorGeneration)
8087 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) {}
8088
8089 bool operator()(ModuleFile &M) {
8090 if (!M.SelectorLookupTable)
8091 return false;
8092
8093 // If we've already searched this module file, skip it now.
8094 if (M.Generation <= PriorGeneration)
8095 return true;
8096
8097 ++Reader.NumMethodPoolTableLookups;
8098 ASTSelectorLookupTable *PoolTable
8099 = (ASTSelectorLookupTable*)M.SelectorLookupTable;
8100 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
8101 if (Pos == PoolTable->end())
8102 return false;
8103
8104 ++Reader.NumMethodPoolTableHits;
8105 ++Reader.NumSelectorsRead;
8106 // FIXME: Not quite happy with the statistics here. We probably should
8107 // disable this tracking when called via LoadSelector.
8108 // Also, should entries without methods count as misses?
8109 ++Reader.NumMethodPoolEntriesRead;
8110 ASTSelectorLookupTrait::data_type Data = *Pos;
8111 if (Reader.DeserializationListener)
8112 Reader.DeserializationListener->SelectorRead(Data.ID, Sel);
8113
8114 InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
8115 FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
8116 InstanceBits = Data.InstanceBits;
8117 FactoryBits = Data.FactoryBits;
8118 InstanceHasMoreThanOneDecl = Data.InstanceHasMoreThanOneDecl;
8119 FactoryHasMoreThanOneDecl = Data.FactoryHasMoreThanOneDecl;
8120 return true;
8121 }
8122
8123 /// Retrieve the instance methods found by this visitor.
8124 ArrayRef<ObjCMethodDecl *> getInstanceMethods() const {
8125 return InstanceMethods;
8126 }
8127
8128 /// Retrieve the instance methods found by this visitor.
8129 ArrayRef<ObjCMethodDecl *> getFactoryMethods() const {
8130 return FactoryMethods;
8131 }
8132
8133 unsigned getInstanceBits() const { return InstanceBits; }
8134 unsigned getFactoryBits() const { return FactoryBits; }
8135
8136 bool instanceHasMoreThanOneDecl() const {
8137 return InstanceHasMoreThanOneDecl;
8138 }
8139
8140 bool factoryHasMoreThanOneDecl() const { return FactoryHasMoreThanOneDecl; }
8141 };
8142
8143} // namespace serialization
8144} // namespace clang
8145
8146/// Add the given set of methods to the method list.
8147static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods,
8148 ObjCMethodList &List) {
8149 for (unsigned I = 0, N = Methods.size(); I != N; ++I) {
8150 S.addMethodToGlobalList(&List, Methods[I]);
8151 }
8152}
8153
8154void ASTReader::ReadMethodPool(Selector Sel) {
8155 // Get the selector generation and update it to the current generation.
8156 unsigned &Generation = SelectorGeneration[Sel];
8157 unsigned PriorGeneration = Generation;
8158 Generation = getGeneration();
8159 SelectorOutOfDate[Sel] = false;
8160
8161 // Search for methods defined with this selector.
8162 ++NumMethodPoolLookups;
8163 ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
8164 ModuleMgr.visit(Visitor);
8165
8166 if (Visitor.getInstanceMethods().empty() &&
8167 Visitor.getFactoryMethods().empty())
8168 return;
8169
8170 ++NumMethodPoolHits;
8171
8172 if (!getSema())
8173 return;
8174
8175 Sema &S = *getSema();
8176 Sema::GlobalMethodPool::iterator Pos
8177 = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first;
8178
8179 Pos->second.first.setBits(Visitor.getInstanceBits());
8180 Pos->second.first.setHasMoreThanOneDecl(Visitor.instanceHasMoreThanOneDecl());
8181 Pos->second.second.setBits(Visitor.getFactoryBits());
8182 Pos->second.second.setHasMoreThanOneDecl(Visitor.factoryHasMoreThanOneDecl());
8183
8184 // Add methods to the global pool *after* setting hasMoreThanOneDecl, since
8185 // when building a module we keep every method individually and may need to
8186 // update hasMoreThanOneDecl as we add the methods.
8187 addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
8188 addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
8189}
8190
8191void ASTReader::updateOutOfDateSelector(Selector Sel) {
8192 if (SelectorOutOfDate[Sel])
8193 ReadMethodPool(Sel);
8194}
8195
8196void ASTReader::ReadKnownNamespaces(
8197 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
8198 Namespaces.clear();
8199
8200 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
8201 if (NamespaceDecl *Namespace
8202 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
8203 Namespaces.push_back(Namespace);
8204 }
8205}
8206
8207void ASTReader::ReadUndefinedButUsed(
8208 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
8209 for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
8210 NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
8211 SourceLocation Loc =
8212 SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]);
8213 Undefined.insert(std::make_pair(D, Loc));
8214 }
8215}
8216
8217void ASTReader::ReadMismatchingDeleteExpressions(llvm::MapVector<
8218 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
8219 Exprs) {
8220 for (unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
8221 FieldDecl *FD = cast<FieldDecl>(GetDecl(DelayedDeleteExprs[Idx++]));
8222 uint64_t Count = DelayedDeleteExprs[Idx++];
8223 for (uint64_t C = 0; C < Count; ++C) {
8224 SourceLocation DeleteLoc =
8225 SourceLocation::getFromRawEncoding(DelayedDeleteExprs[Idx++]);
8226 const bool IsArrayForm = DelayedDeleteExprs[Idx++];
8227 Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
8228 }
8229 }
8230}
8231
8232void ASTReader::ReadTentativeDefinitions(
8233 SmallVectorImpl<VarDecl *> &TentativeDefs) {
8234 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
8235 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
8236 if (Var)
8237 TentativeDefs.push_back(Var);
8238 }
8239 TentativeDefinitions.clear();
8240}
8241
8242void ASTReader::ReadUnusedFileScopedDecls(
8243 SmallVectorImpl<const DeclaratorDecl *> &Decls) {
8244 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
8245 DeclaratorDecl *D
8246 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
8247 if (D)
8248 Decls.push_back(D);
8249 }
8250 UnusedFileScopedDecls.clear();
8251}
8252
8253void ASTReader::ReadDelegatingConstructors(
8254 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
8255 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
8256 CXXConstructorDecl *D
8257 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
8258 if (D)
8259 Decls.push_back(D);
8260 }
8261 DelegatingCtorDecls.clear();
8262}
8263
8264void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
8265 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
8266 TypedefNameDecl *D
8267 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
8268 if (D)
8269 Decls.push_back(D);
8270 }
8271 ExtVectorDecls.clear();
8272}
8273
8274void ASTReader::ReadUnusedLocalTypedefNameCandidates(
8275 llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
8276 for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
8277 ++I) {
8278 TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>(
8279 GetDecl(UnusedLocalTypedefNameCandidates[I]));
8280 if (D)
8281 Decls.insert(D);
8282 }
8283 UnusedLocalTypedefNameCandidates.clear();
8284}
8285
8286void ASTReader::ReadReferencedSelectors(
8287 SmallVectorImpl<std::pair<Selector, SourceLocation>> &Sels) {
8288 if (ReferencedSelectorsData.empty())
8289 return;
8290
8291 // If there are @selector references added them to its pool. This is for
8292 // implementation of -Wselector.
8293 unsigned int DataSize = ReferencedSelectorsData.size()-1;
8294 unsigned I = 0;
8295 while (I < DataSize) {
8296 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
8297 SourceLocation SelLoc
8298 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
8299 Sels.push_back(std::make_pair(Sel, SelLoc));
8300 }
8301 ReferencedSelectorsData.clear();
8302}
8303
8304void ASTReader::ReadWeakUndeclaredIdentifiers(
8305 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo>> &WeakIDs) {
8306 if (WeakUndeclaredIdentifiers.empty())
8307 return;
8308
8309 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
8310 IdentifierInfo *WeakId
8311 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
8312 IdentifierInfo *AliasId
8313 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
8314 SourceLocation Loc
8315 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
8316 bool Used = WeakUndeclaredIdentifiers[I++];
8317 WeakInfo WI(AliasId, Loc);
8318 WI.setUsed(Used);
8319 WeakIDs.push_back(std::make_pair(WeakId, WI));
8320 }
8321 WeakUndeclaredIdentifiers.clear();
8322}
8323
8324void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
8325 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
8326 ExternalVTableUse VT;
8327 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
8328 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
8329 VT.DefinitionRequired = VTableUses[Idx++];
8330 VTables.push_back(VT);
8331 }
8332
8333 VTableUses.clear();
8334}
8335
8336void ASTReader::ReadPendingInstantiations(
8337 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation>> &Pending) {
8338 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
8339 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
8340 SourceLocation Loc
8341 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
8342
8343 Pending.push_back(std::make_pair(D, Loc));
8344 }
8345 PendingInstantiations.clear();
8346}
8347
8348void ASTReader::ReadLateParsedTemplates(
8349 llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
8350 &LPTMap) {
8351 for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N;
8352 /* In loop */) {
8353 FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++]));
8354
8355 auto LT = llvm::make_unique<LateParsedTemplate>();
8356 LT->D = GetDecl(LateParsedTemplates[Idx++]);
8357
8358 ModuleFile *F = getOwningModuleFile(LT->D);
8359 assert(F && "No module");
8360
8361 unsigned TokN = LateParsedTemplates[Idx++];
8362 LT->Toks.reserve(TokN);
8363 for (unsigned T = 0; T < TokN; ++T)
8364 LT->Toks.push_back(ReadToken(*F, LateParsedTemplates, Idx));
8365
8366 LPTMap.insert(std::make_pair(FD, std::move(LT)));
8367 }
8368
8369 LateParsedTemplates.clear();
8370}
8371
8372void ASTReader::LoadSelector(Selector Sel) {
8373 // It would be complicated to avoid reading the methods anyway. So don't.
8374 ReadMethodPool(Sel);
8375}
8376
8377void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
8378 assert(ID && "Non-zero identifier ID required");
8379 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
8380 IdentifiersLoaded[ID - 1] = II;
8381 if (DeserializationListener)
8382 DeserializationListener->IdentifierRead(ID, II);
8383}
8384
8385/// Set the globally-visible declarations associated with the given
8386/// identifier.
8387///
8388/// If the AST reader is currently in a state where the given declaration IDs
8389/// cannot safely be resolved, they are queued until it is safe to resolve
8390/// them.
8391///
8392/// \param II an IdentifierInfo that refers to one or more globally-visible
8393/// declarations.
8394///
8395/// \param DeclIDs the set of declaration IDs with the name @p II that are
8396/// visible at global scope.
8397///
8398/// \param Decls if non-null, this vector will be populated with the set of
8399/// deserialized declarations. These declarations will not be pushed into
8400/// scope.
8401void
8402ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
8403 const SmallVectorImpl<uint32_t> &DeclIDs,
8404 SmallVectorImpl<Decl *> *Decls) {
8405 if (NumCurrentElementsDeserializing && !Decls) {
8406 PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
8407 return;
8408 }
8409
8410 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
8411 if (!SemaObj) {
8412 // Queue this declaration so that it will be added to the
8413 // translation unit scope and identifier's declaration chain
8414 // once a Sema object is known.
8415 PreloadedDeclIDs.push_back(DeclIDs[I]);
8416 continue;
8417 }
8418
8419 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
8420
8421 // If we're simply supposed to record the declarations, do so now.
8422 if (Decls) {
8423 Decls->push_back(D);
8424 continue;
8425 }
8426
8427 // Introduce this declaration into the translation-unit scope
8428 // and add it to the declaration chain for this identifier, so
8429 // that (unqualified) name lookup will find it.
8430 pushExternalDeclIntoScope(D, II);
8431 }
8432}
8433
8434IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
8435 if (ID == 0)
8436 return nullptr;
8437
8438 if (IdentifiersLoaded.empty()) {
8439 Error("no identifier table in AST file");
8440 return nullptr;
8441 }
8442
8443 ID -= 1;
8444 if (!IdentifiersLoaded[ID]) {
8445 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
8446 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
8447 ModuleFile *M = I->second;
8448 unsigned Index = ID - M->BaseIdentifierID;
8449 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
8450
8451 // All of the strings in the AST file are preceded by a 16-bit length.
8452 // Extract that 16-bit length to avoid having to execute strlen().
8453 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
8454 // unsigned integers. This is important to avoid integer overflow when
8455 // we cast them to 'unsigned'.
8456 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
8457 unsigned StrLen = (((unsigned) StrLenPtr[0])
8458 | (((unsigned) StrLenPtr[1]) << 8)) - 1;
8459 auto &II = PP.getIdentifierTable().get(StringRef(Str, StrLen));
8460 IdentifiersLoaded[ID] = &II;
8461 markIdentifierFromAST(*this, II);
8462 if (DeserializationListener)
8463 DeserializationListener->IdentifierRead(ID + 1, &II);
8464 }
8465
8466 return IdentifiersLoaded[ID];
8467}
8468
8469IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
8470 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
8471}
8472
8473IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
8474 if (LocalID < NUM_PREDEF_IDENT_IDS)
8475 return LocalID;
8476
8477 if (!M.ModuleOffsetMap.empty())
8478 ReadModuleOffsetMap(M);
8479
8480 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8481 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
8482 assert(I != M.IdentifierRemap.end()
8483 && "Invalid index into identifier index remap");
8484
8485 return LocalID + I->second;
8486}
8487
8488MacroInfo *ASTReader::getMacro(MacroID ID) {
8489 if (ID == 0)
8490 return nullptr;
8491
8492 if (MacrosLoaded.empty()) {
8493 Error("no macro table in AST file");
8494 return nullptr;
8495 }
8496
8497 ID -= NUM_PREDEF_MACRO_IDS;
8498 if (!MacrosLoaded[ID]) {
8499 GlobalMacroMapType::iterator I
8500 = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
8501 assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
8502 ModuleFile *M = I->second;
8503 unsigned Index = ID - M->BaseMacroID;
8504 MacrosLoaded[ID] = ReadMacroRecord(*M, M->MacroOffsets[Index]);
8505
8506 if (DeserializationListener)
8507 DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS,
8508 MacrosLoaded[ID]);
8509 }
8510
8511 return MacrosLoaded[ID];
8512}
8513
8514MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
8515 if (LocalID < NUM_PREDEF_MACRO_IDS)
8516 return LocalID;
8517
8518 if (!M.ModuleOffsetMap.empty())
8519 ReadModuleOffsetMap(M);
8520
8521 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8522 = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
8523 assert(I != M.MacroRemap.end() && "Invalid index into macro index remap");
8524
8525 return LocalID + I->second;
8526}
8527
8528serialization::SubmoduleID
8529ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
8530 if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
8531 return LocalID;
8532
8533 if (!M.ModuleOffsetMap.empty())
8534 ReadModuleOffsetMap(M);
8535
8536 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8537 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
8538 assert(I != M.SubmoduleRemap.end()
8539 && "Invalid index into submodule index remap");
8540
8541 return LocalID + I->second;
8542}
8543
8544Module *ASTReader::getSubmodule(SubmoduleID GlobalID) {
8545 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
8546 assert(GlobalID == 0 && "Unhandled global submodule ID");
8547 return nullptr;
8548 }
8549
8550 if (GlobalID > SubmodulesLoaded.size()) {
8551 Error("submodule ID out of range in AST file");
8552 return nullptr;
8553 }
8554
8555 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
8556}
8557
8558Module *ASTReader::getModule(unsigned ID) {
8559 return getSubmodule(ID);
8560}
8561
8562bool ASTReader::DeclIsFromPCHWithObjectFile(const Decl *D) {
8563 ModuleFile *MF = getOwningModuleFile(D);
8564 return MF && MF->PCHHasObjectFile;
8565}
8566
8567ModuleFile *ASTReader::getLocalModuleFile(ModuleFile &F, unsigned ID) {
8568 if (ID & 1) {
8569 // It's a module, look it up by submodule ID.
8570 auto I = GlobalSubmoduleMap.find(getGlobalSubmoduleID(F, ID >> 1));
8571 return I == GlobalSubmoduleMap.end() ? nullptr : I->second;
8572 } else {
8573 // It's a prefix (preamble, PCH, ...). Look it up by index.
8574 unsigned IndexFromEnd = ID >> 1;
8575 assert(IndexFromEnd && "got reference to unknown module file");
8576 return getModuleManager().pch_modules().end()[-IndexFromEnd];
8577 }
8578}
8579
8580unsigned ASTReader::getModuleFileID(ModuleFile *F) {
8581 if (!F)
8582 return 1;
8583
8584 // For a file representing a module, use the submodule ID of the top-level
8585 // module as the file ID. For any other kind of file, the number of such
8586 // files loaded beforehand will be the same on reload.
8587 // FIXME: Is this true even if we have an explicit module file and a PCH?
8588 if (F->isModule())
8589 return ((F->BaseSubmoduleID + NUM_PREDEF_SUBMODULE_IDS) << 1) | 1;
8590
8591 auto PCHModules = getModuleManager().pch_modules();
8592 auto I = llvm::find(PCHModules, F);
8593 assert(I != PCHModules.end() && "emitting reference to unknown file");
8594 return (I - PCHModules.end()) << 1;
8595}
8596
8597llvm::Optional<ExternalASTSource::ASTSourceDescriptor>
8598ASTReader::getSourceDescriptor(unsigned ID) {
8599 if (const Module *M = getSubmodule(ID))
8600 return ExternalASTSource::ASTSourceDescriptor(*M);
8601
8602 // If there is only a single PCH, return it instead.
8603 // Chained PCH are not supported.
8604 const auto &PCHChain = ModuleMgr.pch_modules();
8605 if (std::distance(std::begin(PCHChain), std::end(PCHChain))) {
8606 ModuleFile &MF = ModuleMgr.getPrimaryModule();
8607 StringRef ModuleName = llvm::sys::path::filename(MF.OriginalSourceFileName);
8608 StringRef FileName = llvm::sys::path::filename(MF.FileName);
8609 return ASTReader::ASTSourceDescriptor(ModuleName, MF.OriginalDir, FileName,
8610 MF.Signature);
8611 }
8612 return None;
8613}
8614
8615ExternalASTSource::ExtKind ASTReader::hasExternalDefinitions(const Decl *FD) {
8616 auto I = DefinitionSource.find(FD);
8617 if (I == DefinitionSource.end())
8618 return EK_ReplyHazy;
8619 return I->second ? EK_Never : EK_Always;
8620}
8621
8622Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
8623 return DecodeSelector(getGlobalSelectorID(M, LocalID));
8624}
8625
8626Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
8627 if (ID == 0)
8628 return Selector();
8629
8630 if (ID > SelectorsLoaded.size()) {
8631 Error("selector ID out of range in AST file");
8632 return Selector();
8633 }
8634
8635 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == nullptr) {
8636 // Load this selector from the selector table.
8637 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
8638 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
8639 ModuleFile &M = *I->second;
8640 ASTSelectorLookupTrait Trait(*this, M);
8641 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
8642 SelectorsLoaded[ID - 1] =
8643 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
8644 if (DeserializationListener)
8645 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
8646 }
8647
8648 return SelectorsLoaded[ID - 1];
8649}
8650
8651Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
8652 return DecodeSelector(ID);
8653}
8654
8655uint32_t ASTReader::GetNumExternalSelectors() {
8656 // ID 0 (the null selector) is considered an external selector.
8657 return getTotalNumSelectors() + 1;
8658}
8659
8660serialization::SelectorID
8661ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
8662 if (LocalID < NUM_PREDEF_SELECTOR_IDS)
8663 return LocalID;
8664
8665 if (!M.ModuleOffsetMap.empty())
8666 ReadModuleOffsetMap(M);
8667
8668 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8669 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
8670 assert(I != M.SelectorRemap.end()
8671 && "Invalid index into selector index remap");
8672
8673 return LocalID + I->second;
8674}
8675
8676DeclarationName
8677ASTReader::ReadDeclarationName(ModuleFile &F,
8678 const RecordData &Record, unsigned &Idx) {
8679 ASTContext &Context = getContext();
8680 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
8681 switch (Kind) {
8682 case DeclarationName::Identifier:
8683 return DeclarationName(GetIdentifierInfo(F, Record, Idx));
8684
8685 case DeclarationName::ObjCZeroArgSelector:
8686 case DeclarationName::ObjCOneArgSelector:
8687 case DeclarationName::ObjCMultiArgSelector:
8688 return DeclarationName(ReadSelector(F, Record, Idx));
8689
8690 case DeclarationName::CXXConstructorName:
8691 return Context.DeclarationNames.getCXXConstructorName(
8692 Context.getCanonicalType(readType(F, Record, Idx)));
8693
8694 case DeclarationName::CXXDestructorName:
8695 return Context.DeclarationNames.getCXXDestructorName(
8696 Context.getCanonicalType(readType(F, Record, Idx)));
8697
8698 case DeclarationName::CXXDeductionGuideName:
8699 return Context.DeclarationNames.getCXXDeductionGuideName(
8700 ReadDeclAs<TemplateDecl>(F, Record, Idx));
8701
8702 case DeclarationName::CXXConversionFunctionName:
8703 return Context.DeclarationNames.getCXXConversionFunctionName(
8704 Context.getCanonicalType(readType(F, Record, Idx)));
8705
8706 case DeclarationName::CXXOperatorName:
8707 return Context.DeclarationNames.getCXXOperatorName(
8708 (OverloadedOperatorKind)Record[Idx++]);
8709
8710 case DeclarationName::CXXLiteralOperatorName:
8711 return Context.DeclarationNames.getCXXLiteralOperatorName(
8712 GetIdentifierInfo(F, Record, Idx));
8713
8714 case DeclarationName::CXXUsingDirective:
8715 return DeclarationName::getUsingDirectiveName();
8716 }
8717
8718 llvm_unreachable("Invalid NameKind!");
8719}
8720
8721void ASTReader::ReadDeclarationNameLoc(ModuleFile &F,
8722 DeclarationNameLoc &DNLoc,
8723 DeclarationName Name,
8724 const RecordData &Record, unsigned &Idx) {
8725 switch (Name.getNameKind()) {
8726 case DeclarationName::CXXConstructorName:
8727 case DeclarationName::CXXDestructorName:
8728 case DeclarationName::CXXConversionFunctionName:
8729 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
8730 break;
8731
8732 case DeclarationName::CXXOperatorName:
8733 DNLoc.CXXOperatorName.BeginOpNameLoc
8734 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8735 DNLoc.CXXOperatorName.EndOpNameLoc
8736 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8737 break;
8738
8739 case DeclarationName::CXXLiteralOperatorName:
8740 DNLoc.CXXLiteralOperatorName.OpNameLoc
8741 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8742 break;
8743
8744 case DeclarationName::Identifier:
8745 case DeclarationName::ObjCZeroArgSelector:
8746 case DeclarationName::ObjCOneArgSelector:
8747 case DeclarationName::ObjCMultiArgSelector:
8748 case DeclarationName::CXXUsingDirective:
8749 case DeclarationName::CXXDeductionGuideName:
8750 break;
8751 }
8752}
8753
8754void ASTReader::ReadDeclarationNameInfo(ModuleFile &F,
8755 DeclarationNameInfo &NameInfo,
8756 const RecordData &Record, unsigned &Idx) {
8757 NameInfo.setName(ReadDeclarationName(F, Record, Idx));
8758 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
8759 DeclarationNameLoc DNLoc;
8760 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
8761 NameInfo.setInfo(DNLoc);
8762}
8763
8764void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info,
8765 const RecordData &Record, unsigned &Idx) {
8766 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
8767 unsigned NumTPLists = Record[Idx++];
8768 Info.NumTemplParamLists = NumTPLists;
8769 if (NumTPLists) {
8770 Info.TemplParamLists =
8771 new (getContext()) TemplateParameterList *[NumTPLists];
8772 for (unsigned i = 0; i != NumTPLists; ++i)
8773 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
8774 }
8775}
8776
8777TemplateName
8778ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record,
8779 unsigned &Idx) {
8780 ASTContext &Context = getContext();
8781 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
8782 switch (Kind) {
8783 case TemplateName::Template:
8784 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
8785
8786 case TemplateName::OverloadedTemplate: {
8787 unsigned size = Record[Idx++];
8788 UnresolvedSet<8> Decls;
8789 while (size--)
8790 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
8791
8792 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end());
8793 }
8794
8795 case TemplateName::AssumedTemplate: {
8796 DeclarationName Name = ReadDeclarationName(F, Record, Idx);
8797 return Context.getAssumedTemplateName(Name);
8798 }
8799
8800 case TemplateName::QualifiedTemplate: {
8801 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
8802 bool hasTemplKeyword = Record[Idx++];
8803 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
8804 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
8805 }
8806
8807 case TemplateName::DependentTemplate: {
8808 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
8809 if (Record[Idx++]) // isIdentifier
8810 return Context.getDependentTemplateName(NNS,
8811 GetIdentifierInfo(F, Record,
8812 Idx));
8813 return Context.getDependentTemplateName(NNS,
8814 (OverloadedOperatorKind)Record[Idx++]);
8815 }
8816
8817 case TemplateName::SubstTemplateTemplateParm: {
8818 TemplateTemplateParmDecl *param
8819 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
8820 if (!param) return TemplateName();
8821 TemplateName replacement = ReadTemplateName(F, Record, Idx);
8822 return Context.getSubstTemplateTemplateParm(param, replacement);
8823 }
8824
8825 case TemplateName::SubstTemplateTemplateParmPack: {
8826 TemplateTemplateParmDecl *Param
8827 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
8828 if (!Param)
8829 return TemplateName();
8830
8831 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
8832 if (ArgPack.getKind() != TemplateArgument::Pack)
8833 return TemplateName();
8834
8835 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
8836 }
8837 }
8838
8839 llvm_unreachable("Unhandled template name kind!");
8840}
8841
8842TemplateArgument ASTReader::ReadTemplateArgument(ModuleFile &F,
8843 const RecordData &Record,
8844 unsigned &Idx,
8845 bool Canonicalize) {
8846 ASTContext &Context = getContext();
8847 if (Canonicalize) {
8848 // The caller wants a canonical template argument. Sometimes the AST only
8849 // wants template arguments in canonical form (particularly as the template
8850 // argument lists of template specializations) so ensure we preserve that
8851 // canonical form across serialization.
8852 TemplateArgument Arg = ReadTemplateArgument(F, Record, Idx, false);
8853 return Context.getCanonicalTemplateArgument(Arg);
8854 }
8855
8856 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
8857 switch (Kind) {
8858 case TemplateArgument::Null:
8859 return TemplateArgument();
8860 case TemplateArgument::Type:
8861 return TemplateArgument(readType(F, Record, Idx));
8862 case TemplateArgument::Declaration: {
8863 ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx);
8864 return TemplateArgument(D, readType(F, Record, Idx));
8865 }
8866 case TemplateArgument::NullPtr:
8867 return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true);
8868 case TemplateArgument::Integral: {
8869 llvm::APSInt Value = ReadAPSInt(Record, Idx);
8870 QualType T = readType(F, Record, Idx);
8871 return TemplateArgument(Context, Value, T);
8872 }
8873 case TemplateArgument::Template:
8874 return TemplateArgument(ReadTemplateName(F, Record, Idx));
8875 case TemplateArgument::TemplateExpansion: {
8876 TemplateName Name = ReadTemplateName(F, Record, Idx);
8877 Optional<unsigned> NumTemplateExpansions;
8878 if (unsigned NumExpansions = Record[Idx++])
8879 NumTemplateExpansions = NumExpansions - 1;
8880 return TemplateArgument(Name, NumTemplateExpansions);
8881 }
8882 case TemplateArgument::Expression:
8883 return TemplateArgument(ReadExpr(F));
8884 case TemplateArgument::Pack: {
8885 unsigned NumArgs = Record[Idx++];
8886 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
8887 for (unsigned I = 0; I != NumArgs; ++I)
8888 Args[I] = ReadTemplateArgument(F, Record, Idx);
8889 return TemplateArgument(llvm::makeArrayRef(Args, NumArgs));
8890 }
8891 }
8892
8893 llvm_unreachable("Unhandled template argument kind!");
8894}
8895
8896TemplateParameterList *
8897ASTReader::ReadTemplateParameterList(ModuleFile &F,
8898 const RecordData &Record, unsigned &Idx) {
8899 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
8900 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
8901 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
8902
8903 unsigned NumParams = Record[Idx++];
8904 SmallVector<NamedDecl *, 16> Params;
8905 Params.reserve(NumParams);
8906 while (NumParams--)
8907 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
8908
8909 // TODO: Concepts
8910 TemplateParameterList *TemplateParams = TemplateParameterList::Create(
8911 getContext(), TemplateLoc, LAngleLoc, Params, RAngleLoc, nullptr);
8912 return TemplateParams;
8913}
8914
8915void
8916ASTReader::
8917ReadTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
8918 ModuleFile &F, const RecordData &Record,
8919 unsigned &Idx, bool Canonicalize) {
8920 unsigned NumTemplateArgs = Record[Idx++];
8921 TemplArgs.reserve(NumTemplateArgs);
8922 while (NumTemplateArgs--)
8923 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx, Canonicalize));
8924}
8925
8926/// Read a UnresolvedSet structure.
8927void ASTReader::ReadUnresolvedSet(ModuleFile &F, LazyASTUnresolvedSet &Set,
8928 const RecordData &Record, unsigned &Idx) {
8929 unsigned NumDecls = Record[Idx++];
8930 Set.reserve(getContext(), NumDecls);
8931 while (NumDecls--) {
8932 DeclID ID = ReadDeclID(F, Record, Idx);
8933 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
8934 Set.addLazyDecl(getContext(), ID, AS);
8935 }
8936}
8937
8938CXXBaseSpecifier
8939ASTReader::ReadCXXBaseSpecifier(ModuleFile &F,
8940 const RecordData &Record, unsigned &Idx) {
8941 bool isVirtual = static_cast<bool>(Record[Idx++]);
8942 bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
8943 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
8944 bool inheritConstructors = static_cast<bool>(Record[Idx++]);
8945 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
8946 SourceRange Range = ReadSourceRange(F, Record, Idx);
8947 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
8948 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
8949 EllipsisLoc);
8950 Result.setInheritConstructors(inheritConstructors);
8951 return Result;
8952}
8953
8954CXXCtorInitializer **
8955ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record,
8956 unsigned &Idx) {
8957 ASTContext &Context = getContext();
8958 unsigned NumInitializers = Record[Idx++];
8959 assert(NumInitializers && "wrote ctor initializers but have no inits");
8960 auto **CtorInitializers = new (Context) CXXCtorInitializer*[NumInitializers];
8961 for (unsigned i = 0; i != NumInitializers; ++i) {
8962 TypeSourceInfo *TInfo = nullptr;
8963 bool IsBaseVirtual = false;
8964 FieldDecl *Member = nullptr;
8965 IndirectFieldDecl *IndirectMember = nullptr;
8966
8967 CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
8968 switch (Type) {
8969 case CTOR_INITIALIZER_BASE:
8970 TInfo = GetTypeSourceInfo(F, Record, Idx);
8971 IsBaseVirtual = Record[Idx++];
8972 break;
8973
8974 case CTOR_INITIALIZER_DELEGATING:
8975 TInfo = GetTypeSourceInfo(F, Record, Idx);
8976 break;
8977
8978 case CTOR_INITIALIZER_MEMBER:
8979 Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
8980 break;
8981
8982 case CTOR_INITIALIZER_INDIRECT_MEMBER:
8983 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
8984 break;
8985 }
8986
8987 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
8988 Expr *Init = ReadExpr(F);
8989 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
8990 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
8991
8992 CXXCtorInitializer *BOMInit;
8993 if (Type == CTOR_INITIALIZER_BASE)
8994 BOMInit = new (Context)
8995 CXXCtorInitializer(Context, TInfo, IsBaseVirtual, LParenLoc, Init,
8996 RParenLoc, MemberOrEllipsisLoc);
8997 else if (Type == CTOR_INITIALIZER_DELEGATING)
8998 BOMInit = new (Context)
8999 CXXCtorInitializer(Context, TInfo, LParenLoc, Init, RParenLoc);
9000 else if (Member)
9001 BOMInit = new (Context)
9002 CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, LParenLoc,
9003 Init, RParenLoc);
9004 else
9005 BOMInit = new (Context)
9006 CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
9007 LParenLoc, Init, RParenLoc);
9008
9009 if (/*IsWritten*/Record[Idx++]) {
9010 unsigned SourceOrder = Record[Idx++];
9011 BOMInit->setSourceOrder(SourceOrder);
9012 }
9013
9014 CtorInitializers[i] = BOMInit;
9015 }
9016
9017 return CtorInitializers;
9018}
9019
9020NestedNameSpecifier *
9021ASTReader::ReadNestedNameSpecifier(ModuleFile &F,
9022 const RecordData &Record, unsigned &Idx) {
9023 ASTContext &Context = getContext();
9024 unsigned N = Record[Idx++];
9025 NestedNameSpecifier *NNS = nullptr, *Prev = nullptr;
9026 for (unsigned I = 0; I != N; ++I) {
9027 NestedNameSpecifier::SpecifierKind Kind
9028 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
9029 switch (Kind) {
9030 case NestedNameSpecifier::Identifier: {
9031 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
9032 NNS = NestedNameSpecifier::Create(Context, Prev, II);
9033 break;
9034 }
9035
9036 case NestedNameSpecifier::Namespace: {
9037 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
9038 NNS = NestedNameSpecifier::Create(Context, Prev, NS);
9039 break;
9040 }
9041
9042 case NestedNameSpecifier::NamespaceAlias: {
9043 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
9044 NNS = NestedNameSpecifier::Create(Context, Prev, Alias);
9045 break;
9046 }
9047
9048 case NestedNameSpecifier::TypeSpec:
9049 case NestedNameSpecifier::TypeSpecWithTemplate: {
9050 const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
9051 if (!T)
9052 return nullptr;
9053
9054 bool Template = Record[Idx++];
9055 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T);
9056 break;
9057 }
9058
9059 case NestedNameSpecifier::Global:
9060 NNS = NestedNameSpecifier::GlobalSpecifier(Context);
9061 // No associated value, and there can't be a prefix.
9062 break;
9063
9064 case NestedNameSpecifier::Super: {
9065 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
9066 NNS = NestedNameSpecifier::SuperSpecifier(Context, RD);
9067 break;
9068 }
9069 }
9070 Prev = NNS;
9071 }
9072 return NNS;
9073}
9074
9075NestedNameSpecifierLoc
9076ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record,
9077 unsigned &Idx) {
9078 ASTContext &Context = getContext();
9079 unsigned N = Record[Idx++];
9080 NestedNameSpecifierLocBuilder Builder;
9081 for (unsigned I = 0; I != N; ++I) {
9082 NestedNameSpecifier::SpecifierKind Kind
9083 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
9084 switch (Kind) {
9085 case NestedNameSpecifier::Identifier: {
9086 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
9087 SourceRange Range = ReadSourceRange(F, Record, Idx);
9088 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
9089 break;
9090 }
9091
9092 case NestedNameSpecifier::Namespace: {
9093 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
9094 SourceRange Range = ReadSourceRange(F, Record, Idx);
9095 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
9096 break;
9097 }
9098
9099 case NestedNameSpecifier::NamespaceAlias: {
9100 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
9101 SourceRange Range = ReadSourceRange(F, Record, Idx);
9102 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
9103 break;
9104 }
9105
9106 case NestedNameSpecifier::TypeSpec:
9107 case NestedNameSpecifier::TypeSpecWithTemplate: {
9108 bool Template = Record[Idx++];
9109 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
9110 if (!T)
9111 return NestedNameSpecifierLoc();
9112 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
9113
9114 // FIXME: 'template' keyword location not saved anywhere, so we fake it.
9115 Builder.Extend(Context,
9116 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
9117 T->getTypeLoc(), ColonColonLoc);
9118 break;
9119 }
9120
9121 case NestedNameSpecifier::Global: {
9122 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
9123 Builder.MakeGlobal(Context, ColonColonLoc);
9124 break;
9125 }
9126
9127 case NestedNameSpecifier::Super: {
9128 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
9129 SourceRange Range = ReadSourceRange(F, Record, Idx);
9130 Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
9131 break;
9132 }
9133 }
9134 }
9135
9136 return Builder.getWithLocInContext(Context);
9137}
9138
9139SourceRange
9140ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
9141 unsigned &Idx) {
9142 SourceLocation beg = ReadSourceLocation(F, Record, Idx);
9143 SourceLocation end = ReadSourceLocation(F, Record, Idx);
9144 return SourceRange(beg, end);
9145}
9146
9147/// Read an integral value
9148llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
9149 unsigned BitWidth = Record[Idx++];
9150 unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
9151 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
9152 Idx += NumWords;
9153 return Result;
9154}
9155
9156/// Read a signed integral value
9157llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
9158 bool isUnsigned = Record[Idx++];
9159 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
9160}
9161
9162/// Read a floating-point value
9163llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record,
9164 const llvm::fltSemantics &Sem,
9165 unsigned &Idx) {
9166 return llvm::APFloat(Sem, ReadAPInt(Record, Idx));
9167}
9168
9169// Read a string
9170std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
9171 unsigned Len = Record[Idx++];
9172 std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
9173 Idx += Len;
9174 return Result;
9175}
9176
9177std::string ASTReader::ReadPath(ModuleFile &F, const RecordData &Record,
9178 unsigned &Idx) {
9179 std::string Filename = ReadString(Record, Idx);
9180 ResolveImportedPath(F, Filename);
9181 return Filename;
9182}
9183
9184std::string ASTReader::ReadPath(StringRef BaseDirectory,
9185 const RecordData &Record, unsigned &Idx) {
9186 std::string Filename = ReadString(Record, Idx);
9187 if (!BaseDirectory.empty())
9188 ResolveImportedPath(Filename, BaseDirectory);
9189 return Filename;
9190}
9191
9192VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
9193 unsigned &Idx) {
9194 unsigned Major = Record[Idx++];
9195 unsigned Minor = Record[Idx++];
9196 unsigned Subminor = Record[Idx++];
9197 if (Minor == 0)
9198 return VersionTuple(Major);
9199 if (Subminor == 0)
9200 return VersionTuple(Major, Minor - 1);
9201 return VersionTuple(Major, Minor - 1, Subminor - 1);
9202}
9203
9204CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F,
9205 const RecordData &Record,
9206 unsigned &Idx) {
9207 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
9208 return CXXTemporary::Create(getContext(), Decl);
9209}
9210
9211DiagnosticBuilder ASTReader::Diag(unsigned DiagID) const {
9212 return Diag(CurrentImportLoc, DiagID);
9213}
9214
9215DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) const {
9216 return Diags.Report(Loc, DiagID);
9217}
9218
9219/// Retrieve the identifier table associated with the
9220/// preprocessor.
9221IdentifierTable &ASTReader::getIdentifierTable() {
9222 return PP.getIdentifierTable();
9223}
9224
9225/// Record that the given ID maps to the given switch-case
9226/// statement.
9227void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
9228 assert((*CurrSwitchCaseStmts)[ID] == nullptr &&
9229 "Already have a SwitchCase with this ID");
9230 (*CurrSwitchCaseStmts)[ID] = SC;
9231}
9232
9233/// Retrieve the switch-case statement with the given ID.
9234SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
9235 assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID");
9236 return (*CurrSwitchCaseStmts)[ID];
9237}
9238
9239void ASTReader::ClearSwitchCaseIDs() {
9240 CurrSwitchCaseStmts->clear();
9241}
9242
9243void ASTReader::ReadComments() {
9244 ASTContext &Context = getContext();
9245 std::vector<RawComment *> Comments;
9246 for (SmallVectorImpl<std::pair<BitstreamCursor,
9247 serialization::ModuleFile *>>::iterator
9248 I = CommentsCursors.begin(),
9249 E = CommentsCursors.end();
9250 I != E; ++I) {
9251 Comments.clear();
9252 BitstreamCursor &Cursor = I->first;
9253 serialization::ModuleFile &F = *I->second;
9254 SavedStreamPosition SavedPosition(Cursor);
9255
9256 RecordData Record;
9257 while (true) {
9258 llvm::BitstreamEntry Entry =
9259 Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd);
9260
9261 switch (Entry.Kind) {
9262 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
9263 case llvm::BitstreamEntry::Error:
9264 Error("malformed block record in AST file");
9265 return;
9266 case llvm::BitstreamEntry::EndBlock:
9267 goto NextCursor;
9268 case llvm::BitstreamEntry::Record:
9269 // The interesting case.
9270 break;
9271 }
9272
9273 // Read a record.
9274 Record.clear();
9275 switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
9276 case COMMENTS_RAW_COMMENT: {
9277 unsigned Idx = 0;
9278 SourceRange SR = ReadSourceRange(F, Record, Idx);
9279 RawComment::CommentKind Kind =
9280 (RawComment::CommentKind) Record[Idx++];
9281 bool IsTrailingComment = Record[Idx++];
9282 bool IsAlmostTrailingComment = Record[Idx++];
9283 Comments.push_back(new (Context) RawComment(
9284 SR, Kind, IsTrailingComment, IsAlmostTrailingComment));
9285 break;
9286 }
9287 }
9288 }
9289 NextCursor:
9290 // De-serialized SourceLocations get negative FileIDs for other modules,
9291 // potentially invalidating the original order. Sort it again.
9292 llvm::sort(Comments, BeforeThanCompare<RawComment>(SourceMgr));
9293 Context.Comments.addDeserializedComments(Comments);
9294 }
9295}
9296
9297void ASTReader::visitInputFiles(serialization::ModuleFile &MF,
9298 bool IncludeSystem, bool Complain,
9299 llvm::function_ref<void(const serialization::InputFile &IF,
9300 bool isSystem)> Visitor) {
9301 unsigned NumUserInputs = MF.NumUserInputFiles;
9302 unsigned NumInputs = MF.InputFilesLoaded.size();
9303 assert(NumUserInputs <= NumInputs);
9304 unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
9305 for (unsigned I = 0; I < N; ++I) {
9306 bool IsSystem = I >= NumUserInputs;
9307 InputFile IF = getInputFile(MF, I+1, Complain);
9308 Visitor(IF, IsSystem);
9309 }
9310}
9311
9312void ASTReader::visitTopLevelModuleMaps(
9313 serialization::ModuleFile &MF,
9314 llvm::function_ref<void(const FileEntry *FE)> Visitor) {
9315 unsigned NumInputs = MF.InputFilesLoaded.size();
9316 for (unsigned I = 0; I < NumInputs; ++I) {
9317 InputFileInfo IFI = readInputFileInfo(MF, I + 1);
9318 if (IFI.TopLevelModuleMap)
9319 // FIXME: This unnecessarily re-reads the InputFileInfo.
9320 if (auto *FE = getInputFile(MF, I + 1).getFile())
9321 Visitor(FE);
9322 }
9323}
9324
9325std::string ASTReader::getOwningModuleNameForDiagnostic(const Decl *D) {
9326 // If we know the owning module, use it.
9327 if (Module *M = D->getImportedOwningModule())
9328 return M->getFullModuleName();
9329
9330 // Otherwise, use the name of the top-level module the decl is within.
9331 if (ModuleFile *M = getOwningModuleFile(D))
9332 return M->ModuleName;
9333
9334 // Not from a module.
9335 return {};
9336}
9337
9338void ASTReader::finishPendingActions() {
9339 while (!PendingIdentifierInfos.empty() || !PendingFunctionTypes.empty() ||
9340 !PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() ||
9341 !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty() ||
9342 !PendingUpdateRecords.empty()) {
9343 // If any identifiers with corresponding top-level declarations have
9344 // been loaded, load those declarations now.
9345 using TopLevelDeclsMap =
9346 llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2>>;
9347 TopLevelDeclsMap TopLevelDecls;
9348
9349 while (!PendingIdentifierInfos.empty()) {
9350 IdentifierInfo *II = PendingIdentifierInfos.back().first;
9351 SmallVector<uint32_t, 4> DeclIDs =
9352 std::move(PendingIdentifierInfos.back().second);
9353 PendingIdentifierInfos.pop_back();
9354
9355 SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
9356 }
9357
9358 // Load each function type that we deferred loading because it was a
9359 // deduced type that might refer to a local type declared within itself.
9360 for (unsigned I = 0; I != PendingFunctionTypes.size(); ++I) {
9361 auto *FD = PendingFunctionTypes[I].first;
9362 FD->setType(GetType(PendingFunctionTypes[I].second));
9363
9364 // If we gave a function a deduced return type, remember that we need to
9365 // propagate that along the redeclaration chain.
9366 auto *DT = FD->getReturnType()->getContainedDeducedType();
9367 if (DT && DT->isDeduced())
9368 PendingDeducedTypeUpdates.insert(
9369 {FD->getCanonicalDecl(), FD->getReturnType()});
9370 }
9371 PendingFunctionTypes.clear();
9372
9373 // For each decl chain that we wanted to complete while deserializing, mark
9374 // it as "still needs to be completed".
9375 for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
9376 markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
9377 }
9378 PendingIncompleteDeclChains.clear();
9379
9380 // Load pending declaration chains.
9381 for (unsigned I = 0; I != PendingDeclChains.size(); ++I)
9382 loadPendingDeclChain(PendingDeclChains[I].first,
9383 PendingDeclChains[I].second);
9384 PendingDeclChains.clear();
9385
9386 // Make the most recent of the top-level declarations visible.
9387 for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
9388 TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
9389 IdentifierInfo *II = TLD->first;
9390 for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
9391 pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
9392 }
9393 }
9394
9395 // Load any pending macro definitions.
9396 for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
9397 IdentifierInfo *II = PendingMacroIDs.begin()[I].first;
9398 SmallVector<PendingMacroInfo, 2> GlobalIDs;
9399 GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
9400 // Initialize the macro history from chained-PCHs ahead of module imports.
9401 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9402 ++IDIdx) {
9403 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9404 if (!Info.M->isModule())
9405 resolvePendingMacro(II, Info);
9406 }
9407 // Handle module imports.
9408 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9409 ++IDIdx) {
9410 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9411 if (Info.M->isModule())
9412 resolvePendingMacro(II, Info);
9413 }
9414 }
9415 PendingMacroIDs.clear();
9416
9417 // Wire up the DeclContexts for Decls that we delayed setting until
9418 // recursive loading is completed.
9419 while (!PendingDeclContextInfos.empty()) {
9420 PendingDeclContextInfo Info = PendingDeclContextInfos.front();
9421 PendingDeclContextInfos.pop_front();
9422 DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
9423 DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
9424 Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
9425 }
9426
9427 // Perform any pending declaration updates.
9428 while (!PendingUpdateRecords.empty()) {
9429 auto Update = PendingUpdateRecords.pop_back_val();
9430 ReadingKindTracker ReadingKind(Read_Decl, *this);
9431 loadDeclUpdateRecords(Update);
9432 }
9433 }
9434
9435 // At this point, all update records for loaded decls are in place, so any
9436 // fake class definitions should have become real.
9437 assert(PendingFakeDefinitionData.empty() &&
9438 "faked up a class definition but never saw the real one");
9439
9440 // If we deserialized any C++ or Objective-C class definitions, any
9441 // Objective-C protocol definitions, or any redeclarable templates, make sure
9442 // that all redeclarations point to the definitions. Note that this can only
9443 // happen now, after the redeclaration chains have been fully wired.
9444 for (Decl *D : PendingDefinitions) {
9445 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
9446 if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
9447 // Make sure that the TagType points at the definition.
9448 const_cast<TagType*>(TagT)->decl = TD;
9449 }
9450
9451 if (auto RD = dyn_cast<CXXRecordDecl>(D)) {
9452 for (auto *R = getMostRecentExistingDecl(RD); R;
9453 R = R->getPreviousDecl()) {
9454 assert((R == D) ==
9455 cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&
9456 "declaration thinks it's the definition but it isn't");
9457 cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
9458 }
9459 }
9460
9461 continue;
9462 }
9463
9464 if (auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
9465 // Make sure that the ObjCInterfaceType points at the definition.
9466 const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
9467 ->Decl = ID;
9468
9469 for (auto *R = getMostRecentExistingDecl(ID); R; R = R->getPreviousDecl())
9470 cast<ObjCInterfaceDecl>(R)->Data = ID->Data;
9471
9472 continue;
9473 }
9474
9475 if (auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
9476 for (auto *R = getMostRecentExistingDecl(PD); R; R = R->getPreviousDecl())
9477 cast<ObjCProtocolDecl>(R)->Data = PD->Data;
9478
9479 continue;
9480 }
9481
9482 auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
9483 for (auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl())
9484 cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
9485 }
9486 PendingDefinitions.clear();
9487
9488 // Load the bodies of any functions or methods we've encountered. We do
9489 // this now (delayed) so that we can be sure that the declaration chains
9490 // have been fully wired up (hasBody relies on this).
9491 // FIXME: We shouldn't require complete redeclaration chains here.
9492 for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
9493 PBEnd = PendingBodies.end();
9494 PB != PBEnd; ++PB) {
9495 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
9496 // For a function defined inline within a class template, force the
9497 // canonical definition to be the one inside the canonical definition of
9498 // the template. This ensures that we instantiate from a correct view
9499 // of the template.
9500 //
9501 // Sadly we can't do this more generally: we can't be sure that all
9502 // copies of an arbitrary class definition will have the same members
9503 // defined (eg, some member functions may not be instantiated, and some
9504 // special members may or may not have been implicitly defined).
9505 if (auto *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalParent()))
9506 if (RD->isDependentContext() && !RD->isThisDeclarationADefinition())
9507 continue;
9508
9509 // FIXME: Check for =delete/=default?
9510 // FIXME: Complain about ODR violations here?
9511 const FunctionDecl *Defn = nullptr;
9512 if (!getContext().getLangOpts().Modules || !FD->hasBody(Defn)) {
9513 FD->setLazyBody(PB->second);
9514 } else {
9515 auto *NonConstDefn = const_cast<FunctionDecl*>(Defn);
9516 mergeDefinitionVisibility(NonConstDefn, FD);
9517
9518 if (!FD->isLateTemplateParsed() &&
9519 !NonConstDefn->isLateTemplateParsed() &&
9520 FD->getODRHash() != NonConstDefn->getODRHash()) {
9521 if (!isa<CXXMethodDecl>(FD)) {
9522 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9523 } else if (FD->getLexicalParent()->isFileContext() &&
9524 NonConstDefn->getLexicalParent()->isFileContext()) {
9525 // Only diagnose out-of-line method definitions. If they are
9526 // in class definitions, then an error will be generated when
9527 // processing the class bodies.
9528 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9529 }
9530 }
9531 }
9532 continue;
9533 }
9534
9535 ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
9536 if (!getContext().getLangOpts().Modules || !MD->hasBody())
9537 MD->setLazyBody(PB->second);
9538 }
9539 PendingBodies.clear();
9540
9541 // Do some cleanup.
9542 for (auto *ND : PendingMergedDefinitionsToDeduplicate)
9543 getContext().deduplicateMergedDefinitonsFor(ND);
9544 PendingMergedDefinitionsToDeduplicate.clear();
9545}
9546
9547void ASTReader::diagnoseOdrViolations() {
9548 if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty() &&
9549 PendingFunctionOdrMergeFailures.empty() &&
9550 PendingEnumOdrMergeFailures.empty())
9551 return;
9552
9553 // Trigger the import of the full definition of each class that had any
9554 // odr-merging problems, so we can produce better diagnostics for them.
9555 // These updates may in turn find and diagnose some ODR failures, so take
9556 // ownership of the set first.
9557 auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
9558 PendingOdrMergeFailures.clear();
9559 for (auto &Merge : OdrMergeFailures) {
9560 Merge.first->buildLookup();
9561 Merge.first->decls_begin();
9562 Merge.first->bases_begin();
9563 Merge.first->vbases_begin();
9564 for (auto &RecordPair : Merge.second) {
9565 auto *RD = RecordPair.first;
9566 RD->decls_begin();
9567 RD->bases_begin();
9568 RD->vbases_begin();
9569 }
9570 }
9571
9572 // Trigger the import of functions.
9573 auto FunctionOdrMergeFailures = std::move(PendingFunctionOdrMergeFailures);
9574 PendingFunctionOdrMergeFailures.clear();
9575 for (auto &Merge : FunctionOdrMergeFailures) {
9576 Merge.first->buildLookup();
9577 Merge.first->decls_begin();
9578 Merge.first->getBody();
9579 for (auto &FD : Merge.second) {
9580 FD->buildLookup();
9581 FD->decls_begin();
9582 FD->getBody();
9583 }
9584 }
9585
9586 // Trigger the import of enums.
9587 auto EnumOdrMergeFailures = std::move(PendingEnumOdrMergeFailures);
9588 PendingEnumOdrMergeFailures.clear();
9589 for (auto &Merge : EnumOdrMergeFailures) {
9590 Merge.first->decls_begin();
9591 for (auto &Enum : Merge.second) {
9592 Enum->decls_begin();
9593 }
9594 }
9595
9596 // For each declaration from a merged context, check that the canonical
9597 // definition of that context also contains a declaration of the same
9598 // entity.
9599 //
9600 // Caution: this loop does things that might invalidate iterators into
9601 // PendingOdrMergeChecks. Don't turn this into a range-based for loop!
9602 while (!PendingOdrMergeChecks.empty()) {
9603 NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
9604
9605 // FIXME: Skip over implicit declarations for now. This matters for things
9606 // like implicitly-declared special member functions. This isn't entirely
9607 // correct; we can end up with multiple unmerged declarations of the same
9608 // implicit entity.
9609 if (D->isImplicit())
9610 continue;
9611
9612 DeclContext *CanonDef = D->getDeclContext();
9613
9614 bool Found = false;
9615 const Decl *DCanon = D->getCanonicalDecl();
9616
9617 for (auto RI : D->redecls()) {
9618 if (RI->getLexicalDeclContext() == CanonDef) {
9619 Found = true;
9620 break;
9621 }
9622 }
9623 if (Found)
9624 continue;
9625
9626 // Quick check failed, time to do the slow thing. Note, we can't just
9627 // look up the name of D in CanonDef here, because the member that is
9628 // in CanonDef might not be found by name lookup (it might have been
9629 // replaced by a more recent declaration in the lookup table), and we
9630 // can't necessarily find it in the redeclaration chain because it might
9631 // be merely mergeable, not redeclarable.
9632 llvm::SmallVector<const NamedDecl*, 4> Candidates;
9633 for (auto *CanonMember : CanonDef->decls()) {
9634 if (CanonMember->getCanonicalDecl() == DCanon) {
9635 // This can happen if the declaration is merely mergeable and not
9636 // actually redeclarable (we looked for redeclarations earlier).
9637 //
9638 // FIXME: We should be able to detect this more efficiently, without
9639 // pulling in all of the members of CanonDef.
9640 Found = true;
9641 break;
9642 }
9643 if (auto *ND = dyn_cast<NamedDecl>(CanonMember))
9644 if (ND->getDeclName() == D->getDeclName())
9645 Candidates.push_back(ND);
9646 }
9647
9648 if (!Found) {
9649 // The AST doesn't like TagDecls becoming invalid after they've been
9650 // completed. We only really need to mark FieldDecls as invalid here.
9651 if (!isa<TagDecl>(D))
9652 D->setInvalidDecl();
9653
9654 // Ensure we don't accidentally recursively enter deserialization while
9655 // we're producing our diagnostic.
9656 Deserializing RecursionGuard(this);
9657
9658 std::string CanonDefModule =
9659 getOwningModuleNameForDiagnostic(cast<Decl>(CanonDef));
9660 Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl)
9661 << D << getOwningModuleNameForDiagnostic(D)
9662 << CanonDef << CanonDefModule.empty() << CanonDefModule;
9663
9664 if (Candidates.empty())
9665 Diag(cast<Decl>(CanonDef)->getLocation(),
9666 diag::note_module_odr_violation_no_possible_decls) << D;
9667 else {
9668 for (unsigned I = 0, N = Candidates.size(); I != N; ++I)
9669 Diag(Candidates[I]->getLocation(),
9670 diag::note_module_odr_violation_possible_decl)
9671 << Candidates[I];
9672 }
9673
9674 DiagnosedOdrMergeFailures.insert(CanonDef);
9675 }
9676 }
9677
9678 if (OdrMergeFailures.empty() && FunctionOdrMergeFailures.empty() &&
9679 EnumOdrMergeFailures.empty())
9680 return;
9681
9682 // Ensure we don't accidentally recursively enter deserialization while
9683 // we're producing our diagnostics.
9684 Deserializing RecursionGuard(this);
9685
9686 // Common code for hashing helpers.
9687 ODRHash Hash;
9688 auto ComputeQualTypeODRHash = [&Hash](QualType Ty) {
9689 Hash.clear();
9690 Hash.AddQualType(Ty);
9691 return Hash.CalculateHash();
9692 };
9693
9694 auto ComputeODRHash = [&Hash](const Stmt *S) {
9695 assert(S);
9696 Hash.clear();
9697 Hash.AddStmt(S);
9698 return Hash.CalculateHash();
9699 };
9700
9701 auto ComputeSubDeclODRHash = [&Hash](const Decl *D) {
9702 assert(D);
9703 Hash.clear();
9704 Hash.AddSubDecl(D);
9705 return Hash.CalculateHash();
9706 };
9707
9708 auto ComputeTemplateArgumentODRHash = [&Hash](const TemplateArgument &TA) {
9709 Hash.clear();
9710 Hash.AddTemplateArgument(TA);
9711 return Hash.CalculateHash();
9712 };
9713
9714 auto ComputeTemplateParameterListODRHash =
9715 [&Hash](const TemplateParameterList *TPL) {
9716 assert(TPL);
9717 Hash.clear();
9718 Hash.AddTemplateParameterList(TPL);
9719 return Hash.CalculateHash();
9720 };
9721
9722 // Issue any pending ODR-failure diagnostics.
9723 for (auto &Merge : OdrMergeFailures) {
9724 // If we've already pointed out a specific problem with this class, don't
9725 // bother issuing a general "something's different" diagnostic.
9726 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
9727 continue;
9728
9729 bool Diagnosed = false;
9730 CXXRecordDecl *FirstRecord = Merge.first;
9731 std::string FirstModule = getOwningModuleNameForDiagnostic(FirstRecord);
9732 for (auto &RecordPair : Merge.second) {
9733 CXXRecordDecl *SecondRecord = RecordPair.first;
9734 // Multiple different declarations got merged together; tell the user
9735 // where they came from.
9736 if (FirstRecord == SecondRecord)
9737 continue;
9738
9739 std::string SecondModule = getOwningModuleNameForDiagnostic(SecondRecord);
9740
9741 auto *FirstDD = FirstRecord->DefinitionData;
9742 auto *SecondDD = RecordPair.second;
9743
9744 assert(FirstDD && SecondDD && "Definitions without DefinitionData");
9745
9746 // Diagnostics from DefinitionData are emitted here.
9747 if (FirstDD != SecondDD) {
9748 enum ODRDefinitionDataDifference {
9749 NumBases,
9750 NumVBases,
9751 BaseType,
9752 BaseVirtual,
9753 BaseAccess,
9754 };
9755 auto ODRDiagError = [FirstRecord, &FirstModule,
9756 this](SourceLocation Loc, SourceRange Range,
9757 ODRDefinitionDataDifference DiffType) {
9758 return Diag(Loc, diag::err_module_odr_violation_definition_data)
9759 << FirstRecord << FirstModule.empty() << FirstModule << Range
9760 << DiffType;
9761 };
9762 auto ODRDiagNote = [&SecondModule,
9763 this](SourceLocation Loc, SourceRange Range,
9764 ODRDefinitionDataDifference DiffType) {
9765 return Diag(Loc, diag::note_module_odr_violation_definition_data)
9766 << SecondModule << Range << DiffType;
9767 };
9768
9769 unsigned FirstNumBases = FirstDD->NumBases;
9770 unsigned FirstNumVBases = FirstDD->NumVBases;
9771 unsigned SecondNumBases = SecondDD->NumBases;
9772 unsigned SecondNumVBases = SecondDD->NumVBases;
9773
9774 auto GetSourceRange = [](struct CXXRecordDecl::DefinitionData *DD) {
9775 unsigned NumBases = DD->NumBases;
9776 if (NumBases == 0) return SourceRange();
9777 auto bases = DD->bases();
9778 return SourceRange(bases[0].getBeginLoc(),
9779 bases[NumBases - 1].getEndLoc());
9780 };
9781
9782 if (FirstNumBases != SecondNumBases) {
9783 ODRDiagError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
9784 NumBases)
9785 << FirstNumBases;
9786 ODRDiagNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
9787 NumBases)
9788 << SecondNumBases;
9789 Diagnosed = true;
9790 break;
9791 }
9792
9793 if (FirstNumVBases != SecondNumVBases) {
9794 ODRDiagError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
9795 NumVBases)
9796 << FirstNumVBases;
9797 ODRDiagNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
9798 NumVBases)
9799 << SecondNumVBases;
9800 Diagnosed = true;
9801 break;
9802 }
9803
9804 auto FirstBases = FirstDD->bases();
9805 auto SecondBases = SecondDD->bases();
9806 unsigned i = 0;
9807 for (i = 0; i < FirstNumBases; ++i) {
9808 auto FirstBase = FirstBases[i];
9809 auto SecondBase = SecondBases[i];
9810 if (ComputeQualTypeODRHash(FirstBase.getType()) !=
9811 ComputeQualTypeODRHash(SecondBase.getType())) {
9812 ODRDiagError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
9813 BaseType)
9814 << (i + 1) << FirstBase.getType();
9815 ODRDiagNote(SecondRecord->getLocation(),
9816 SecondBase.getSourceRange(), BaseType)
9817 << (i + 1) << SecondBase.getType();
9818 break;
9819 }
9820
9821 if (FirstBase.isVirtual() != SecondBase.isVirtual()) {
9822 ODRDiagError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
9823 BaseVirtual)
9824 << (i + 1) << FirstBase.isVirtual() << FirstBase.getType();
9825 ODRDiagNote(SecondRecord->getLocation(),
9826 SecondBase.getSourceRange(), BaseVirtual)
9827 << (i + 1) << SecondBase.isVirtual() << SecondBase.getType();
9828 break;
9829 }
9830
9831 if (FirstBase.getAccessSpecifierAsWritten() !=
9832 SecondBase.getAccessSpecifierAsWritten()) {
9833 ODRDiagError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
9834 BaseAccess)
9835 << (i + 1) << FirstBase.getType()
9836 << (int)FirstBase.getAccessSpecifierAsWritten();
9837 ODRDiagNote(SecondRecord->getLocation(),
9838 SecondBase.getSourceRange(), BaseAccess)
9839 << (i + 1) << SecondBase.getType()
9840 << (int)SecondBase.getAccessSpecifierAsWritten();
9841 break;
9842 }
9843 }
9844
9845 if (i != FirstNumBases) {
9846 Diagnosed = true;
9847 break;
9848 }
9849 }
9850
9851 using DeclHashes = llvm::SmallVector<std::pair<Decl *, unsigned>, 4>;
9852
9853 const ClassTemplateDecl *FirstTemplate =
9854 FirstRecord->getDescribedClassTemplate();
9855 const ClassTemplateDecl *SecondTemplate =
9856 SecondRecord->getDescribedClassTemplate();
9857
9858 assert(!FirstTemplate == !SecondTemplate &&
9859 "Both pointers should be null or non-null");
9860
9861 enum ODRTemplateDifference {
9862 ParamEmptyName,
9863 ParamName,
9864 ParamSingleDefaultArgument,
9865 ParamDifferentDefaultArgument,
9866 };
9867
9868 if (FirstTemplate && SecondTemplate) {
9869 DeclHashes FirstTemplateHashes;
9870 DeclHashes SecondTemplateHashes;
9871
9872 auto PopulateTemplateParameterHashs =
9873 [&ComputeSubDeclODRHash](DeclHashes &Hashes,
9874 const ClassTemplateDecl *TD) {
9875 for (auto *D : TD->getTemplateParameters()->asArray()) {
9876 Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
9877 }
9878 };
9879
9880 PopulateTemplateParameterHashs(FirstTemplateHashes, FirstTemplate);
9881 PopulateTemplateParameterHashs(SecondTemplateHashes, SecondTemplate);
9882
9883 assert(FirstTemplateHashes.size() == SecondTemplateHashes.size() &&
9884 "Number of template parameters should be equal.");
9885
9886 auto FirstIt = FirstTemplateHashes.begin();
9887 auto FirstEnd = FirstTemplateHashes.end();
9888 auto SecondIt = SecondTemplateHashes.begin();
9889 for (; FirstIt != FirstEnd; ++FirstIt, ++SecondIt) {
9890 if (FirstIt->second == SecondIt->second)
9891 continue;
9892
9893 auto ODRDiagError = [FirstRecord, &FirstModule,
9894 this](SourceLocation Loc, SourceRange Range,
9895 ODRTemplateDifference DiffType) {
9896 return Diag(Loc, diag::err_module_odr_violation_template_parameter)
9897 << FirstRecord << FirstModule.empty() << FirstModule << Range
9898 << DiffType;
9899 };
9900 auto ODRDiagNote = [&SecondModule,
9901 this](SourceLocation Loc, SourceRange Range,
9902 ODRTemplateDifference DiffType) {
9903 return Diag(Loc, diag::note_module_odr_violation_template_parameter)
9904 << SecondModule << Range << DiffType;
9905 };
9906
9907 const NamedDecl* FirstDecl = cast<NamedDecl>(FirstIt->first);
9908 const NamedDecl* SecondDecl = cast<NamedDecl>(SecondIt->first);
9909
9910 assert(FirstDecl->getKind() == SecondDecl->getKind() &&
9911 "Parameter Decl's should be the same kind.");
9912
9913 DeclarationName FirstName = FirstDecl->getDeclName();
9914 DeclarationName SecondName = SecondDecl->getDeclName();
9915
9916 if (FirstName != SecondName) {
9917 const bool FirstNameEmpty =
9918 FirstName.isIdentifier() && !FirstName.getAsIdentifierInfo();
9919 const bool SecondNameEmpty =
9920 SecondName.isIdentifier() && !SecondName.getAsIdentifierInfo();
9921 assert((!FirstNameEmpty || !SecondNameEmpty) &&
9922 "Both template parameters cannot be unnamed.");
9923 ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9924 FirstNameEmpty ? ParamEmptyName : ParamName)
9925 << FirstName;
9926 ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9927 SecondNameEmpty ? ParamEmptyName : ParamName)
9928 << SecondName;
9929 break;
9930 }
9931
9932 switch (FirstDecl->getKind()) {
9933 default:
9934 llvm_unreachable("Invalid template parameter type.");
9935 case Decl::TemplateTypeParm: {
9936 const auto *FirstParam = cast<TemplateTypeParmDecl>(FirstDecl);
9937 const auto *SecondParam = cast<TemplateTypeParmDecl>(SecondDecl);
9938 const bool HasFirstDefaultArgument =
9939 FirstParam->hasDefaultArgument() &&
9940 !FirstParam->defaultArgumentWasInherited();
9941 const bool HasSecondDefaultArgument =
9942 SecondParam->hasDefaultArgument() &&
9943 !SecondParam->defaultArgumentWasInherited();
9944
9945 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
9946 ODRDiagError(FirstDecl->getLocation(),
9947 FirstDecl->getSourceRange(),
9948 ParamSingleDefaultArgument)
9949 << HasFirstDefaultArgument;
9950 ODRDiagNote(SecondDecl->getLocation(),
9951 SecondDecl->getSourceRange(),
9952 ParamSingleDefaultArgument)
9953 << HasSecondDefaultArgument;
9954 break;
9955 }
9956
9957 assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
9958 "Expecting default arguments.");
9959
9960 ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9961 ParamDifferentDefaultArgument);
9962 ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9963 ParamDifferentDefaultArgument);
9964
9965 break;
9966 }
9967 case Decl::NonTypeTemplateParm: {
9968 const auto *FirstParam = cast<NonTypeTemplateParmDecl>(FirstDecl);
9969 const auto *SecondParam = cast<NonTypeTemplateParmDecl>(SecondDecl);
9970 const bool HasFirstDefaultArgument =
9971 FirstParam->hasDefaultArgument() &&
9972 !FirstParam->defaultArgumentWasInherited();
9973 const bool HasSecondDefaultArgument =
9974 SecondParam->hasDefaultArgument() &&
9975 !SecondParam->defaultArgumentWasInherited();
9976
9977 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
9978 ODRDiagError(FirstDecl->getLocation(),
9979 FirstDecl->getSourceRange(),
9980 ParamSingleDefaultArgument)
9981 << HasFirstDefaultArgument;
9982 ODRDiagNote(SecondDecl->getLocation(),
9983 SecondDecl->getSourceRange(),
9984 ParamSingleDefaultArgument)
9985 << HasSecondDefaultArgument;
9986 break;
9987 }
9988
9989 assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
9990 "Expecting default arguments.");
9991
9992 ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9993 ParamDifferentDefaultArgument);
9994 ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9995 ParamDifferentDefaultArgument);
9996
9997 break;
9998 }
9999 case Decl::TemplateTemplateParm: {
10000 const auto *FirstParam = cast<TemplateTemplateParmDecl>(FirstDecl);
10001 const auto *SecondParam =
10002 cast<TemplateTemplateParmDecl>(SecondDecl);
10003 const bool HasFirstDefaultArgument =
10004 FirstParam->hasDefaultArgument() &&
10005 !FirstParam->defaultArgumentWasInherited();
10006 const bool HasSecondDefaultArgument =
10007 SecondParam->hasDefaultArgument() &&
10008 !SecondParam->defaultArgumentWasInherited();
10009
10010 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
10011 ODRDiagError(FirstDecl->getLocation(),
10012 FirstDecl->getSourceRange(),
10013 ParamSingleDefaultArgument)
10014 << HasFirstDefaultArgument;
10015 ODRDiagNote(SecondDecl->getLocation(),
10016 SecondDecl->getSourceRange(),
10017 ParamSingleDefaultArgument)
10018 << HasSecondDefaultArgument;
10019 break;
10020 }
10021
10022 assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
10023 "Expecting default arguments.");
10024
10025 ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
10026 ParamDifferentDefaultArgument);
10027 ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
10028 ParamDifferentDefaultArgument);
10029
10030 break;
10031 }
10032 }
10033
10034 break;
10035 }
10036
10037 if (FirstIt != FirstEnd) {
10038 Diagnosed = true;
10039 break;
10040 }
10041 }
10042
10043 DeclHashes FirstHashes;
10044 DeclHashes SecondHashes;
10045
10046 auto PopulateHashes = [&ComputeSubDeclODRHash, FirstRecord](
10047 DeclHashes &Hashes, CXXRecordDecl *Record) {
10048 for (auto *D : Record->decls()) {
10049 // Due to decl merging, the first CXXRecordDecl is the parent of
10050 // Decls in both records.
10051 if (!ODRHash::isWhitelistedDecl(D, FirstRecord))
10052 continue;
10053 Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
10054 }
10055 };
10056 PopulateHashes(FirstHashes, FirstRecord);
10057 PopulateHashes(SecondHashes, SecondRecord);
10058
10059 // Used with err_module_odr_violation_mismatch_decl and
10060 // note_module_odr_violation_mismatch_decl
10061 // This list should be the same Decl's as in ODRHash::isWhiteListedDecl
10062 enum {
10063 EndOfClass,
10064 PublicSpecifer,
10065 PrivateSpecifer,
10066 ProtectedSpecifer,
10067 StaticAssert,
10068 Field,
10069 CXXMethod,
10070 TypeAlias,
10071 TypeDef,
10072 Var,
10073 Friend,
10074 FunctionTemplate,
10075 Other
10076 } FirstDiffType = Other,
10077 SecondDiffType = Other;
10078
10079 auto DifferenceSelector = [](Decl *D) {
10080 assert(D && "valid Decl required");
10081 switch (D->getKind()) {
10082 default:
10083 return Other;
10084 case Decl::AccessSpec:
10085 switch (D->getAccess()) {
10086 case AS_public:
10087 return PublicSpecifer;
10088 case AS_private:
10089 return PrivateSpecifer;
10090 case AS_protected:
10091 return ProtectedSpecifer;
10092 case AS_none:
10093 break;
10094 }
10095 llvm_unreachable("Invalid access specifier");
10096 case Decl::StaticAssert:
10097 return StaticAssert;
10098 case Decl::Field:
10099 return Field;
10100 case Decl::CXXMethod:
10101 case Decl::CXXConstructor:
10102 case Decl::CXXDestructor:
10103 return CXXMethod;
10104 case Decl::TypeAlias:
10105 return TypeAlias;
10106 case Decl::Typedef:
10107 return TypeDef;
10108 case Decl::Var:
10109 return Var;
10110 case Decl::Friend:
10111 return Friend;
10112 case Decl::FunctionTemplate:
10113 return FunctionTemplate;
10114 }
10115 };
10116
10117 Decl *FirstDecl = nullptr;
10118 Decl *SecondDecl = nullptr;
10119 auto FirstIt = FirstHashes.begin();
10120 auto SecondIt = SecondHashes.begin();
10121
10122 // If there is a diagnoseable difference, FirstDiffType and
10123 // SecondDiffType will not be Other and FirstDecl and SecondDecl will be
10124 // filled in if not EndOfClass.
10125 while (FirstIt != FirstHashes.end() || SecondIt != SecondHashes.end()) {
10126 if (FirstIt != FirstHashes.end() && SecondIt != SecondHashes.end() &&
10127 FirstIt->second == SecondIt->second) {
10128 ++FirstIt;
10129 ++SecondIt;
10130 continue;
10131 }
10132
10133 FirstDecl = FirstIt == FirstHashes.end() ? nullptr : FirstIt->first;
10134 SecondDecl = SecondIt == SecondHashes.end() ? nullptr : SecondIt->first;
10135
10136 FirstDiffType = FirstDecl ? DifferenceSelector(FirstDecl) : EndOfClass;
10137 SecondDiffType =
10138 SecondDecl ? DifferenceSelector(SecondDecl) : EndOfClass;
10139
10140 break;
10141 }
10142
10143 if (FirstDiffType == Other || SecondDiffType == Other) {
10144 // Reaching this point means an unexpected Decl was encountered
10145 // or no difference was detected. This causes a generic error
10146 // message to be emitted.
10147 Diag(FirstRecord->getLocation(),
10148 diag::err_module_odr_violation_different_definitions)
10149 << FirstRecord << FirstModule.empty() << FirstModule;
10150
10151 if (FirstDecl) {
10152 Diag(FirstDecl->getLocation(), diag::note_first_module_difference)
10153 << FirstRecord << FirstDecl->getSourceRange();
10154 }
10155
10156 Diag(SecondRecord->getLocation(),
10157 diag::note_module_odr_violation_different_definitions)
10158 << SecondModule;
10159
10160 if (SecondDecl) {
10161 Diag(SecondDecl->getLocation(), diag::note_second_module_difference)
10162 << SecondDecl->getSourceRange();
10163 }
10164
10165 Diagnosed = true;
10166 break;
10167 }
10168
10169 if (FirstDiffType != SecondDiffType) {
10170 SourceLocation FirstLoc;
10171 SourceRange FirstRange;
10172 if (FirstDiffType == EndOfClass) {
10173 FirstLoc = FirstRecord->getBraceRange().getEnd();
10174 } else {
10175 FirstLoc = FirstIt->first->getLocation();
10176 FirstRange = FirstIt->first->getSourceRange();
10177 }
10178 Diag(FirstLoc, diag::err_module_odr_violation_mismatch_decl)
10179 << FirstRecord << FirstModule.empty() << FirstModule << FirstRange
10180 << FirstDiffType;
10181
10182 SourceLocation SecondLoc;
10183 SourceRange SecondRange;
10184 if (SecondDiffType == EndOfClass) {
10185 SecondLoc = SecondRecord->getBraceRange().getEnd();
10186 } else {
10187 SecondLoc = SecondDecl->getLocation();
10188 SecondRange = SecondDecl->getSourceRange();
10189 }
10190 Diag(SecondLoc, diag::note_module_odr_violation_mismatch_decl)
10191 << SecondModule << SecondRange << SecondDiffType;
10192 Diagnosed = true;
10193 break;
10194 }
10195
10196 assert(FirstDiffType == SecondDiffType);
10197
10198 // Used with err_module_odr_violation_mismatch_decl_diff and
10199 // note_module_odr_violation_mismatch_decl_diff
10200 enum ODRDeclDifference {
10201 StaticAssertCondition,
10202 StaticAssertMessage,
10203 StaticAssertOnlyMessage,
10204 FieldName,
10205 FieldTypeName,
10206 FieldSingleBitField,
10207 FieldDifferentWidthBitField,
10208 FieldSingleMutable,
10209 FieldSingleInitializer,
10210 FieldDifferentInitializers,
10211 MethodName,
10212 MethodDeleted,
10213 MethodDefaulted,
10214 MethodVirtual,
10215 MethodStatic,
10216 MethodVolatile,
10217 MethodConst,
10218 MethodInline,
10219 MethodNumberParameters,
10220 MethodParameterType,
10221 MethodParameterName,
10222 MethodParameterSingleDefaultArgument,
10223 MethodParameterDifferentDefaultArgument,
10224 MethodNoTemplateArguments,
10225 MethodDifferentNumberTemplateArguments,
10226 MethodDifferentTemplateArgument,
10227 MethodSingleBody,
10228 MethodDifferentBody,
10229 TypedefName,
10230 TypedefType,
10231 VarName,
10232 VarType,
10233 VarSingleInitializer,
10234 VarDifferentInitializer,
10235 VarConstexpr,
10236 FriendTypeFunction,
10237 FriendType,
10238 FriendFunction,
10239 FunctionTemplateDifferentNumberParameters,
10240 FunctionTemplateParameterDifferentKind,
10241 FunctionTemplateParameterName,
10242 FunctionTemplateParameterSingleDefaultArgument,
10243 FunctionTemplateParameterDifferentDefaultArgument,
10244 FunctionTemplateParameterDifferentType,
10245 FunctionTemplatePackParameter,
10246 };
10247
10248 // These lambdas have the common portions of the ODR diagnostics. This
10249 // has the same return as Diag(), so addition parameters can be passed
10250 // in with operator<<
10251 auto ODRDiagError = [FirstRecord, &FirstModule, this](
10252 SourceLocation Loc, SourceRange Range, ODRDeclDifference DiffType) {
10253 return Diag(Loc, diag::err_module_odr_violation_mismatch_decl_diff)
10254 << FirstRecord << FirstModule.empty() << FirstModule << Range
10255 << DiffType;
10256 };
10257 auto ODRDiagNote = [&SecondModule, this](
10258 SourceLocation Loc, SourceRange Range, ODRDeclDifference DiffType) {
10259 return Diag(Loc, diag::note_module_odr_violation_mismatch_decl_diff)
10260 << SecondModule << Range << DiffType;
10261 };
10262
10263 switch (FirstDiffType) {
10264 case Other:
10265 case EndOfClass:
10266 case PublicSpecifer:
10267 case PrivateSpecifer:
10268 case ProtectedSpecifer:
10269 llvm_unreachable("Invalid diff type");
10270
10271 case StaticAssert: {
10272 StaticAssertDecl *FirstSA = cast<StaticAssertDecl>(FirstDecl);
10273 StaticAssertDecl *SecondSA = cast<StaticAssertDecl>(SecondDecl);
10274
10275 Expr *FirstExpr = FirstSA->getAssertExpr();
10276 Expr *SecondExpr = SecondSA->getAssertExpr();
10277 unsigned FirstODRHash = ComputeODRHash(FirstExpr);
10278 unsigned SecondODRHash = ComputeODRHash(SecondExpr);
10279 if (FirstODRHash != SecondODRHash) {
10280 ODRDiagError(FirstExpr->getBeginLoc(), FirstExpr->getSourceRange(),
10281 StaticAssertCondition);
10282 ODRDiagNote(SecondExpr->getBeginLoc(), SecondExpr->getSourceRange(),
10283 StaticAssertCondition);
10284 Diagnosed = true;
10285 break;
10286 }
10287
10288 StringLiteral *FirstStr = FirstSA->getMessage();
10289 StringLiteral *SecondStr = SecondSA->getMessage();
10290 assert((FirstStr || SecondStr) && "Both messages cannot be empty");
10291 if ((FirstStr && !SecondStr) || (!FirstStr && SecondStr)) {
10292 SourceLocation FirstLoc, SecondLoc;
10293 SourceRange FirstRange, SecondRange;
10294 if (FirstStr) {
10295 FirstLoc = FirstStr->getBeginLoc();
10296 FirstRange = FirstStr->getSourceRange();
10297 } else {
10298 FirstLoc = FirstSA->getBeginLoc();
10299 FirstRange = FirstSA->getSourceRange();
10300 }
10301 if (SecondStr) {
10302 SecondLoc = SecondStr->getBeginLoc();
10303 SecondRange = SecondStr->getSourceRange();
10304 } else {
10305 SecondLoc = SecondSA->getBeginLoc();
10306 SecondRange = SecondSA->getSourceRange();
10307 }
10308 ODRDiagError(FirstLoc, FirstRange, StaticAssertOnlyMessage)
10309 << (FirstStr == nullptr);
10310 ODRDiagNote(SecondLoc, SecondRange, StaticAssertOnlyMessage)
10311 << (SecondStr == nullptr);
10312 Diagnosed = true;
10313 break;
10314 }
10315
10316 if (FirstStr && SecondStr &&
10317 FirstStr->getString() != SecondStr->getString()) {
10318 ODRDiagError(FirstStr->getBeginLoc(), FirstStr->getSourceRange(),
10319 StaticAssertMessage);
10320 ODRDiagNote(SecondStr->getBeginLoc(), SecondStr->getSourceRange(),
10321 StaticAssertMessage);
10322 Diagnosed = true;
10323 break;
10324 }
10325 break;
10326 }
10327 case Field: {
10328 FieldDecl *FirstField = cast<FieldDecl>(FirstDecl);
10329 FieldDecl *SecondField = cast<FieldDecl>(SecondDecl);
10330 IdentifierInfo *FirstII = FirstField->getIdentifier();
10331 IdentifierInfo *SecondII = SecondField->getIdentifier();
10332 if (FirstII->getName() != SecondII->getName()) {
10333 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10334 FieldName)
10335 << FirstII;
10336 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10337 FieldName)
10338 << SecondII;
10339
10340 Diagnosed = true;
10341 break;
10342 }
10343
10344 assert(getContext().hasSameType(FirstField->getType(),
10345 SecondField->getType()));
10346
10347 QualType FirstType = FirstField->getType();
10348 QualType SecondType = SecondField->getType();
10349 if (ComputeQualTypeODRHash(FirstType) !=
10350 ComputeQualTypeODRHash(SecondType)) {
10351 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10352 FieldTypeName)
10353 << FirstII << FirstType;
10354 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10355 FieldTypeName)
10356 << SecondII << SecondType;
10357
10358 Diagnosed = true;
10359 break;
10360 }
10361
10362 const bool IsFirstBitField = FirstField->isBitField();
10363 const bool IsSecondBitField = SecondField->isBitField();
10364 if (IsFirstBitField != IsSecondBitField) {
10365 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10366 FieldSingleBitField)
10367 << FirstII << IsFirstBitField;
10368 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10369 FieldSingleBitField)
10370 << SecondII << IsSecondBitField;
10371 Diagnosed = true;
10372 break;
10373 }
10374
10375 if (IsFirstBitField && IsSecondBitField) {
10376 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10377 FieldDifferentWidthBitField)
10378 << FirstII << FirstField->getBitWidth()->getSourceRange();
10379 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10380 FieldDifferentWidthBitField)
10381 << SecondII << SecondField->getBitWidth()->getSourceRange();
10382 Diagnosed = true;
10383 break;
10384 }
10385
10386 const bool IsFirstMutable = FirstField->isMutable();
10387 const bool IsSecondMutable = SecondField->isMutable();
10388 if (IsFirstMutable != IsSecondMutable) {
10389 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10390 FieldSingleMutable)
10391 << FirstII << IsFirstMutable;
10392 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10393 FieldSingleMutable)
10394 << SecondII << IsSecondMutable;
10395 Diagnosed = true;
10396 break;
10397 }
10398
10399 const Expr *FirstInitializer = FirstField->getInClassInitializer();
10400 const Expr *SecondInitializer = SecondField->getInClassInitializer();
10401 if ((!FirstInitializer && SecondInitializer) ||
10402 (FirstInitializer && !SecondInitializer)) {
10403 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10404 FieldSingleInitializer)
10405 << FirstII << (FirstInitializer != nullptr);
10406 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10407 FieldSingleInitializer)
10408 << SecondII << (SecondInitializer != nullptr);
10409 Diagnosed = true;
10410 break;
10411 }
10412
10413 if (FirstInitializer && SecondInitializer) {
10414 unsigned FirstInitHash = ComputeODRHash(FirstInitializer);
10415 unsigned SecondInitHash = ComputeODRHash(SecondInitializer);
10416 if (FirstInitHash != SecondInitHash) {
10417 ODRDiagError(FirstField->getLocation(),
10418 FirstField->getSourceRange(),
10419 FieldDifferentInitializers)
10420 << FirstII << FirstInitializer->getSourceRange();
10421 ODRDiagNote(SecondField->getLocation(),
10422 SecondField->getSourceRange(),
10423 FieldDifferentInitializers)
10424 << SecondII << SecondInitializer->getSourceRange();
10425 Diagnosed = true;
10426 break;
10427 }
10428 }
10429
10430 break;
10431 }
10432 case CXXMethod: {
10433 enum {
10434 DiagMethod,
10435 DiagConstructor,
10436 DiagDestructor,
10437 } FirstMethodType,
10438 SecondMethodType;
10439 auto GetMethodTypeForDiagnostics = [](const CXXMethodDecl* D) {
10440 if (isa<CXXConstructorDecl>(D)) return DiagConstructor;
10441 if (isa<CXXDestructorDecl>(D)) return DiagDestructor;
10442 return DiagMethod;
10443 };
10444 const CXXMethodDecl *FirstMethod = cast<CXXMethodDecl>(FirstDecl);
10445 const CXXMethodDecl *SecondMethod = cast<CXXMethodDecl>(SecondDecl);
10446 FirstMethodType = GetMethodTypeForDiagnostics(FirstMethod);
10447 SecondMethodType = GetMethodTypeForDiagnostics(SecondMethod);
10448 auto FirstName = FirstMethod->getDeclName();
10449 auto SecondName = SecondMethod->getDeclName();
10450 if (FirstMethodType != SecondMethodType || FirstName != SecondName) {
10451 ODRDiagError(FirstMethod->getLocation(),
10452 FirstMethod->getSourceRange(), MethodName)
10453 << FirstMethodType << FirstName;
10454 ODRDiagNote(SecondMethod->getLocation(),
10455 SecondMethod->getSourceRange(), MethodName)
10456 << SecondMethodType << SecondName;
10457
10458 Diagnosed = true;
10459 break;
10460 }
10461
10462 const bool FirstDeleted = FirstMethod->isDeletedAsWritten();
10463 const bool SecondDeleted = SecondMethod->isDeletedAsWritten();
10464 if (FirstDeleted != SecondDeleted) {
10465 ODRDiagError(FirstMethod->getLocation(),
10466 FirstMethod->getSourceRange(), MethodDeleted)
10467 << FirstMethodType << FirstName << FirstDeleted;
10468
10469 ODRDiagNote(SecondMethod->getLocation(),
10470 SecondMethod->getSourceRange(), MethodDeleted)
10471 << SecondMethodType << SecondName << SecondDeleted;
10472 Diagnosed = true;
10473 break;
10474 }
10475
10476 const bool FirstDefaulted = FirstMethod->isExplicitlyDefaulted();
10477 const bool SecondDefaulted = SecondMethod->isExplicitlyDefaulted();
10478 if (FirstDefaulted != SecondDefaulted) {
10479 ODRDiagError(FirstMethod->getLocation(),
10480 FirstMethod->getSourceRange(), MethodDefaulted)
10481 << FirstMethodType << FirstName << FirstDefaulted;
10482
10483 ODRDiagNote(SecondMethod->getLocation(),
10484 SecondMethod->getSourceRange(), MethodDefaulted)
10485 << SecondMethodType << SecondName << SecondDefaulted;
10486 Diagnosed = true;
10487 break;
10488 }
10489
10490 const bool FirstVirtual = FirstMethod->isVirtualAsWritten();
10491 const bool SecondVirtual = SecondMethod->isVirtualAsWritten();
10492 const bool FirstPure = FirstMethod->isPure();
10493 const bool SecondPure = SecondMethod->isPure();
10494 if ((FirstVirtual || SecondVirtual) &&
10495 (FirstVirtual != SecondVirtual || FirstPure != SecondPure)) {
10496 ODRDiagError(FirstMethod->getLocation(),
10497 FirstMethod->getSourceRange(), MethodVirtual)
10498 << FirstMethodType << FirstName << FirstPure << FirstVirtual;
10499 ODRDiagNote(SecondMethod->getLocation(),
10500 SecondMethod->getSourceRange(), MethodVirtual)
10501 << SecondMethodType << SecondName << SecondPure << SecondVirtual;
10502 Diagnosed = true;
10503 break;
10504 }
10505
10506 // CXXMethodDecl::isStatic uses the canonical Decl. With Decl merging,
10507 // FirstDecl is the canonical Decl of SecondDecl, so the storage
10508 // class needs to be checked instead.
10509 const auto FirstStorage = FirstMethod->getStorageClass();
10510 const auto SecondStorage = SecondMethod->getStorageClass();
10511 const bool FirstStatic = FirstStorage == SC_Static;
10512 const bool SecondStatic = SecondStorage == SC_Static;
10513 if (FirstStatic != SecondStatic) {
10514 ODRDiagError(FirstMethod->getLocation(),
10515 FirstMethod->getSourceRange(), MethodStatic)
10516 << FirstMethodType << FirstName << FirstStatic;
10517 ODRDiagNote(SecondMethod->getLocation(),
10518 SecondMethod->getSourceRange(), MethodStatic)
10519 << SecondMethodType << SecondName << SecondStatic;
10520 Diagnosed = true;
10521 break;
10522 }
10523
10524 const bool FirstVolatile = FirstMethod->isVolatile();
10525 const bool SecondVolatile = SecondMethod->isVolatile();
10526 if (FirstVolatile != SecondVolatile) {
10527 ODRDiagError(FirstMethod->getLocation(),
10528 FirstMethod->getSourceRange(), MethodVolatile)
10529 << FirstMethodType << FirstName << FirstVolatile;
10530 ODRDiagNote(SecondMethod->getLocation(),
10531 SecondMethod->getSourceRange(), MethodVolatile)
10532 << SecondMethodType << SecondName << SecondVolatile;
10533 Diagnosed = true;
10534 break;
10535 }
10536
10537 const bool FirstConst = FirstMethod->isConst();
10538 const bool SecondConst = SecondMethod->isConst();
10539 if (FirstConst != SecondConst) {
10540 ODRDiagError(FirstMethod->getLocation(),
10541 FirstMethod->getSourceRange(), MethodConst)
10542 << FirstMethodType << FirstName << FirstConst;
10543 ODRDiagNote(SecondMethod->getLocation(),
10544 SecondMethod->getSourceRange(), MethodConst)
10545 << SecondMethodType << SecondName << SecondConst;
10546 Diagnosed = true;
10547 break;
10548 }
10549
10550 const bool FirstInline = FirstMethod->isInlineSpecified();
10551 const bool SecondInline = SecondMethod->isInlineSpecified();
10552 if (FirstInline != SecondInline) {
10553 ODRDiagError(FirstMethod->getLocation(),
10554 FirstMethod->getSourceRange(), MethodInline)
10555 << FirstMethodType << FirstName << FirstInline;
10556 ODRDiagNote(SecondMethod->getLocation(),
10557 SecondMethod->getSourceRange(), MethodInline)
10558 << SecondMethodType << SecondName << SecondInline;
10559 Diagnosed = true;
10560 break;
10561 }
10562
10563 const unsigned FirstNumParameters = FirstMethod->param_size();
10564 const unsigned SecondNumParameters = SecondMethod->param_size();
10565 if (FirstNumParameters != SecondNumParameters) {
10566 ODRDiagError(FirstMethod->getLocation(),
10567 FirstMethod->getSourceRange(), MethodNumberParameters)
10568 << FirstMethodType << FirstName << FirstNumParameters;
10569 ODRDiagNote(SecondMethod->getLocation(),
10570 SecondMethod->getSourceRange(), MethodNumberParameters)
10571 << SecondMethodType << SecondName << SecondNumParameters;
10572 Diagnosed = true;
10573 break;
10574 }
10575
10576 // Need this status boolean to know when break out of the switch.
10577 bool ParameterMismatch = false;
10578 for (unsigned I = 0; I < FirstNumParameters; ++I) {
10579 const ParmVarDecl *FirstParam = FirstMethod->getParamDecl(I);
10580 const ParmVarDecl *SecondParam = SecondMethod->getParamDecl(I);
10581
10582 QualType FirstParamType = FirstParam->getType();
10583 QualType SecondParamType = SecondParam->getType();
10584 if (FirstParamType != SecondParamType &&
10585 ComputeQualTypeODRHash(FirstParamType) !=
10586 ComputeQualTypeODRHash(SecondParamType)) {
10587 if (const DecayedType *ParamDecayedType =
10588 FirstParamType->getAs<DecayedType>()) {
10589 ODRDiagError(FirstMethod->getLocation(),
10590 FirstMethod->getSourceRange(), MethodParameterType)
10591 << FirstMethodType << FirstName << (I + 1) << FirstParamType
10592 << true << ParamDecayedType->getOriginalType();
10593 } else {
10594 ODRDiagError(FirstMethod->getLocation(),
10595 FirstMethod->getSourceRange(), MethodParameterType)
10596 << FirstMethodType << FirstName << (I + 1) << FirstParamType
10597 << false;
10598 }
10599
10600 if (const DecayedType *ParamDecayedType =
10601 SecondParamType->getAs<DecayedType>()) {
10602 ODRDiagNote(SecondMethod->getLocation(),
10603 SecondMethod->getSourceRange(), MethodParameterType)
10604 << SecondMethodType << SecondName << (I + 1)
10605 << SecondParamType << true
10606 << ParamDecayedType->getOriginalType();
10607 } else {
10608 ODRDiagNote(SecondMethod->getLocation(),
10609 SecondMethod->getSourceRange(), MethodParameterType)
10610 << SecondMethodType << SecondName << (I + 1)
10611 << SecondParamType << false;
10612 }
10613 ParameterMismatch = true;
10614 break;
10615 }
10616
10617 DeclarationName FirstParamName = FirstParam->getDeclName();
10618 DeclarationName SecondParamName = SecondParam->getDeclName();
10619 if (FirstParamName != SecondParamName) {
10620 ODRDiagError(FirstMethod->getLocation(),
10621 FirstMethod->getSourceRange(), MethodParameterName)
10622 << FirstMethodType << FirstName << (I + 1) << FirstParamName;
10623 ODRDiagNote(SecondMethod->getLocation(),
10624 SecondMethod->getSourceRange(), MethodParameterName)
10625 << SecondMethodType << SecondName << (I + 1) << SecondParamName;
10626 ParameterMismatch = true;
10627 break;
10628 }
10629
10630 const Expr *FirstInit = FirstParam->getInit();
10631 const Expr *SecondInit = SecondParam->getInit();
10632 if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
10633 ODRDiagError(FirstMethod->getLocation(),
10634 FirstMethod->getSourceRange(),
10635 MethodParameterSingleDefaultArgument)
10636 << FirstMethodType << FirstName << (I + 1)
10637 << (FirstInit == nullptr)
10638 << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
10639 ODRDiagNote(SecondMethod->getLocation(),
10640 SecondMethod->getSourceRange(),
10641 MethodParameterSingleDefaultArgument)
10642 << SecondMethodType << SecondName << (I + 1)
10643 << (SecondInit == nullptr)
10644 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
10645 ParameterMismatch = true;
10646 break;
10647 }
10648
10649 if (FirstInit && SecondInit &&
10650 ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
10651 ODRDiagError(FirstMethod->getLocation(),
10652 FirstMethod->getSourceRange(),
10653 MethodParameterDifferentDefaultArgument)
10654 << FirstMethodType << FirstName << (I + 1)
10655 << FirstInit->getSourceRange();
10656 ODRDiagNote(SecondMethod->getLocation(),
10657 SecondMethod->getSourceRange(),
10658 MethodParameterDifferentDefaultArgument)
10659 << SecondMethodType << SecondName << (I + 1)
10660 << SecondInit->getSourceRange();
10661 ParameterMismatch = true;
10662 break;
10663
10664 }
10665 }
10666
10667 if (ParameterMismatch) {
10668 Diagnosed = true;
10669 break;
10670 }
10671
10672 const auto *FirstTemplateArgs =
10673 FirstMethod->getTemplateSpecializationArgs();
10674 const auto *SecondTemplateArgs =
10675 SecondMethod->getTemplateSpecializationArgs();
10676
10677 if ((FirstTemplateArgs && !SecondTemplateArgs) ||
10678 (!FirstTemplateArgs && SecondTemplateArgs)) {
10679 ODRDiagError(FirstMethod->getLocation(),
10680 FirstMethod->getSourceRange(), MethodNoTemplateArguments)
10681 << FirstMethodType << FirstName << (FirstTemplateArgs != nullptr);
10682 ODRDiagNote(SecondMethod->getLocation(),
10683 SecondMethod->getSourceRange(), MethodNoTemplateArguments)
10684 << SecondMethodType << SecondName
10685 << (SecondTemplateArgs != nullptr);
10686
10687 Diagnosed = true;
10688 break;
10689 }
10690
10691 if (FirstTemplateArgs && SecondTemplateArgs) {
10692 // Remove pack expansions from argument list.
10693 auto ExpandTemplateArgumentList =
10694 [](const TemplateArgumentList *TAL) {
10695 llvm::SmallVector<const TemplateArgument *, 8> ExpandedList;
10696 for (const TemplateArgument &TA : TAL->asArray()) {
10697 if (TA.getKind() != TemplateArgument::Pack) {
10698 ExpandedList.push_back(&TA);
10699 continue;
10700 }
10701 for (const TemplateArgument &PackTA : TA.getPackAsArray()) {
10702 ExpandedList.push_back(&PackTA);
10703 }
10704 }
10705 return ExpandedList;
10706 };
10707 llvm::SmallVector<const TemplateArgument *, 8> FirstExpandedList =
10708 ExpandTemplateArgumentList(FirstTemplateArgs);
10709 llvm::SmallVector<const TemplateArgument *, 8> SecondExpandedList =
10710 ExpandTemplateArgumentList(SecondTemplateArgs);
10711
10712 if (FirstExpandedList.size() != SecondExpandedList.size()) {
10713 ODRDiagError(FirstMethod->getLocation(),
10714 FirstMethod->getSourceRange(),
10715 MethodDifferentNumberTemplateArguments)
10716 << FirstMethodType << FirstName
10717 << (unsigned)FirstExpandedList.size();
10718 ODRDiagNote(SecondMethod->getLocation(),
10719 SecondMethod->getSourceRange(),
10720 MethodDifferentNumberTemplateArguments)
10721 << SecondMethodType << SecondName
10722 << (unsigned)SecondExpandedList.size();
10723
10724 Diagnosed = true;
10725 break;
10726 }
10727
10728 bool TemplateArgumentMismatch = false;
10729 for (unsigned i = 0, e = FirstExpandedList.size(); i != e; ++i) {
10730 const TemplateArgument &FirstTA = *FirstExpandedList[i],
10731 &SecondTA = *SecondExpandedList[i];
10732 if (ComputeTemplateArgumentODRHash(FirstTA) ==
10733 ComputeTemplateArgumentODRHash(SecondTA)) {
10734 continue;
10735 }
10736
10737 ODRDiagError(FirstMethod->getLocation(),
10738 FirstMethod->getSourceRange(),
10739 MethodDifferentTemplateArgument)
10740 << FirstMethodType << FirstName << FirstTA << i + 1;
10741 ODRDiagNote(SecondMethod->getLocation(),
10742 SecondMethod->getSourceRange(),
10743 MethodDifferentTemplateArgument)
10744 << SecondMethodType << SecondName << SecondTA << i + 1;
10745
10746 TemplateArgumentMismatch = true;
10747 break;
10748 }
10749
10750 if (TemplateArgumentMismatch) {
10751 Diagnosed = true;
10752 break;
10753 }
10754 }
10755
10756 // Compute the hash of the method as if it has no body.
10757 auto ComputeCXXMethodODRHash = [&Hash](const CXXMethodDecl *D) {
10758 Hash.clear();
10759 Hash.AddFunctionDecl(D, true /*SkipBody*/);
10760 return Hash.CalculateHash();
10761 };
10762
10763 // Compare the hash generated to the hash stored. A difference means
10764 // that a body was present in the original source. Due to merging,
10765 // the stardard way of detecting a body will not work.
10766 const bool HasFirstBody =
10767 ComputeCXXMethodODRHash(FirstMethod) != FirstMethod->getODRHash();
10768 const bool HasSecondBody =
10769 ComputeCXXMethodODRHash(SecondMethod) != SecondMethod->getODRHash();
10770
10771 if (HasFirstBody != HasSecondBody) {
10772 ODRDiagError(FirstMethod->getLocation(),
10773 FirstMethod->getSourceRange(), MethodSingleBody)
10774 << FirstMethodType << FirstName << HasFirstBody;
10775 ODRDiagNote(SecondMethod->getLocation(),
10776 SecondMethod->getSourceRange(), MethodSingleBody)
10777 << SecondMethodType << SecondName << HasSecondBody;
10778 Diagnosed = true;
10779 break;
10780 }
10781
10782 if (HasFirstBody && HasSecondBody) {
10783 ODRDiagError(FirstMethod->getLocation(),
10784 FirstMethod->getSourceRange(), MethodDifferentBody)
10785 << FirstMethodType << FirstName;
10786 ODRDiagNote(SecondMethod->getLocation(),
10787 SecondMethod->getSourceRange(), MethodDifferentBody)
10788 << SecondMethodType << SecondName;
10789 Diagnosed = true;
10790 break;
10791 }
10792
10793 break;
10794 }
10795 case TypeAlias:
10796 case TypeDef: {
10797 TypedefNameDecl *FirstTD = cast<TypedefNameDecl>(FirstDecl);
10798 TypedefNameDecl *SecondTD = cast<TypedefNameDecl>(SecondDecl);
10799 auto FirstName = FirstTD->getDeclName();
10800 auto SecondName = SecondTD->getDeclName();
10801 if (FirstName != SecondName) {
10802 ODRDiagError(FirstTD->getLocation(), FirstTD->getSourceRange(),
10803 TypedefName)
10804 << (FirstDiffType == TypeAlias) << FirstName;
10805 ODRDiagNote(SecondTD->getLocation(), SecondTD->getSourceRange(),
10806 TypedefName)
10807 << (FirstDiffType == TypeAlias) << SecondName;
10808 Diagnosed = true;
10809 break;
10810 }
10811
10812 QualType FirstType = FirstTD->getUnderlyingType();
10813 QualType SecondType = SecondTD->getUnderlyingType();
10814 if (ComputeQualTypeODRHash(FirstType) !=
10815 ComputeQualTypeODRHash(SecondType)) {
10816 ODRDiagError(FirstTD->getLocation(), FirstTD->getSourceRange(),
10817 TypedefType)
10818 << (FirstDiffType == TypeAlias) << FirstName << FirstType;
10819 ODRDiagNote(SecondTD->getLocation(), SecondTD->getSourceRange(),
10820 TypedefType)
10821 << (FirstDiffType == TypeAlias) << SecondName << SecondType;
10822 Diagnosed = true;
10823 break;
10824 }
10825 break;
10826 }
10827 case Var: {
10828 VarDecl *FirstVD = cast<VarDecl>(FirstDecl);
10829 VarDecl *SecondVD = cast<VarDecl>(SecondDecl);
10830 auto FirstName = FirstVD->getDeclName();
10831 auto SecondName = SecondVD->getDeclName();
10832 if (FirstName != SecondName) {
10833 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10834 VarName)
10835 << FirstName;
10836 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10837 VarName)
10838 << SecondName;
10839 Diagnosed = true;
10840 break;
10841 }
10842
10843 QualType FirstType = FirstVD->getType();
10844 QualType SecondType = SecondVD->getType();
10845 if (ComputeQualTypeODRHash(FirstType) !=
10846 ComputeQualTypeODRHash(SecondType)) {
10847 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10848 VarType)
10849 << FirstName << FirstType;
10850 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10851 VarType)
10852 << SecondName << SecondType;
10853 Diagnosed = true;
10854 break;
10855 }
10856
10857 const Expr *FirstInit = FirstVD->getInit();
10858 const Expr *SecondInit = SecondVD->getInit();
10859 if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
10860 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10861 VarSingleInitializer)
10862 << FirstName << (FirstInit == nullptr)
10863 << (FirstInit ? FirstInit->getSourceRange(): SourceRange());
10864 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10865 VarSingleInitializer)
10866 << SecondName << (SecondInit == nullptr)
10867 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
10868 Diagnosed = true;
10869 break;
10870 }
10871
10872 if (FirstInit && SecondInit &&
10873 ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
10874 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10875 VarDifferentInitializer)
10876 << FirstName << FirstInit->getSourceRange();
10877 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10878 VarDifferentInitializer)
10879 << SecondName << SecondInit->getSourceRange();
10880 Diagnosed = true;
10881 break;
10882 }
10883
10884 const bool FirstIsConstexpr = FirstVD->isConstexpr();
10885 const bool SecondIsConstexpr = SecondVD->isConstexpr();
10886 if (FirstIsConstexpr != SecondIsConstexpr) {
10887 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10888 VarConstexpr)
10889 << FirstName << FirstIsConstexpr;
10890 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10891 VarConstexpr)
10892 << SecondName << SecondIsConstexpr;
10893 Diagnosed = true;
10894 break;
10895 }
10896 break;
10897 }
10898 case Friend: {
10899 FriendDecl *FirstFriend = cast<FriendDecl>(FirstDecl);
10900 FriendDecl *SecondFriend = cast<FriendDecl>(SecondDecl);
10901
10902 NamedDecl *FirstND = FirstFriend->getFriendDecl();
10903 NamedDecl *SecondND = SecondFriend->getFriendDecl();
10904
10905 TypeSourceInfo *FirstTSI = FirstFriend->getFriendType();
10906 TypeSourceInfo *SecondTSI = SecondFriend->getFriendType();
10907
10908 if (FirstND && SecondND) {
10909 ODRDiagError(FirstFriend->getFriendLoc(),
10910 FirstFriend->getSourceRange(), FriendFunction)
10911 << FirstND;
10912 ODRDiagNote(SecondFriend->getFriendLoc(),
10913 SecondFriend->getSourceRange(), FriendFunction)
10914 << SecondND;
10915
10916 Diagnosed = true;
10917 break;
10918 }
10919
10920 if (FirstTSI && SecondTSI) {
10921 QualType FirstFriendType = FirstTSI->getType();
10922 QualType SecondFriendType = SecondTSI->getType();
10923 assert(ComputeQualTypeODRHash(FirstFriendType) !=
10924 ComputeQualTypeODRHash(SecondFriendType));
10925 ODRDiagError(FirstFriend->getFriendLoc(),
10926 FirstFriend->getSourceRange(), FriendType)
10927 << FirstFriendType;
10928 ODRDiagNote(SecondFriend->getFriendLoc(),
10929 SecondFriend->getSourceRange(), FriendType)
10930 << SecondFriendType;
10931 Diagnosed = true;
10932 break;
10933 }
10934
10935 ODRDiagError(FirstFriend->getFriendLoc(), FirstFriend->getSourceRange(),
10936 FriendTypeFunction)
10937 << (FirstTSI == nullptr);
10938 ODRDiagNote(SecondFriend->getFriendLoc(),
10939 SecondFriend->getSourceRange(), FriendTypeFunction)
10940 << (SecondTSI == nullptr);
10941
10942 Diagnosed = true;
10943 break;
10944 }
10945 case FunctionTemplate: {
10946 FunctionTemplateDecl *FirstTemplate =
10947 cast<FunctionTemplateDecl>(FirstDecl);
10948 FunctionTemplateDecl *SecondTemplate =
10949 cast<FunctionTemplateDecl>(SecondDecl);
10950
10951 TemplateParameterList *FirstTPL =
10952 FirstTemplate->getTemplateParameters();
10953 TemplateParameterList *SecondTPL =
10954 SecondTemplate->getTemplateParameters();
10955
10956 if (FirstTPL->size() != SecondTPL->size()) {
10957 ODRDiagError(FirstTemplate->getLocation(),
10958 FirstTemplate->getSourceRange(),
10959 FunctionTemplateDifferentNumberParameters)
10960 << FirstTemplate << FirstTPL->size();
10961 ODRDiagNote(SecondTemplate->getLocation(),
10962 SecondTemplate->getSourceRange(),
10963 FunctionTemplateDifferentNumberParameters)
10964 << SecondTemplate << SecondTPL->size();
10965
10966 Diagnosed = true;
10967 break;
10968 }
10969
10970 bool ParameterMismatch = false;
10971 for (unsigned i = 0, e = FirstTPL->size(); i != e; ++i) {
10972 NamedDecl *FirstParam = FirstTPL->getParam(i);
10973 NamedDecl *SecondParam = SecondTPL->getParam(i);
10974
10975 if (FirstParam->getKind() != SecondParam->getKind()) {
10976 enum {
10977 TemplateTypeParameter,
10978 NonTypeTemplateParameter,
10979 TemplateTemplateParameter,
10980 };
10981 auto GetParamType = [](NamedDecl *D) {
10982 switch (D->getKind()) {
10983 default:
10984 llvm_unreachable("Unexpected template parameter type");
10985 case Decl::TemplateTypeParm:
10986 return TemplateTypeParameter;
10987 case Decl::NonTypeTemplateParm:
10988 return NonTypeTemplateParameter;
10989 case Decl::TemplateTemplateParm:
10990 return TemplateTemplateParameter;
10991 }
10992 };
10993
10994 ODRDiagError(FirstTemplate->getLocation(),
10995 FirstTemplate->getSourceRange(),
10996 FunctionTemplateParameterDifferentKind)
10997 << FirstTemplate << (i + 1) << GetParamType(FirstParam);
10998 ODRDiagNote(SecondTemplate->getLocation(),
10999 SecondTemplate->getSourceRange(),
11000 FunctionTemplateParameterDifferentKind)
11001 << SecondTemplate << (i + 1) << GetParamType(SecondParam);
11002
11003 ParameterMismatch = true;
11004 break;
11005 }
11006
11007 if (FirstParam->getName() != SecondParam->getName()) {
11008 ODRDiagError(FirstTemplate->getLocation(),
11009 FirstTemplate->getSourceRange(),
11010 FunctionTemplateParameterName)
11011 << FirstTemplate << (i + 1) << (bool)FirstParam->getIdentifier()
11012 << FirstParam;
11013 ODRDiagNote(SecondTemplate->getLocation(),
11014 SecondTemplate->getSourceRange(),
11015 FunctionTemplateParameterName)
11016 << SecondTemplate << (i + 1)
11017 << (bool)SecondParam->getIdentifier() << SecondParam;
11018 ParameterMismatch = true;
11019 break;
11020 }
11021
11022 if (isa<TemplateTypeParmDecl>(FirstParam) &&
11023 isa<TemplateTypeParmDecl>(SecondParam)) {
11024 TemplateTypeParmDecl *FirstTTPD =
11025 cast<TemplateTypeParmDecl>(FirstParam);
11026 TemplateTypeParmDecl *SecondTTPD =
11027 cast<TemplateTypeParmDecl>(SecondParam);
11028 bool HasFirstDefaultArgument =
11029 FirstTTPD->hasDefaultArgument() &&
11030 !FirstTTPD->defaultArgumentWasInherited();
11031 bool HasSecondDefaultArgument =
11032 SecondTTPD->hasDefaultArgument() &&
11033 !SecondTTPD->defaultArgumentWasInherited();
11034 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
11035 ODRDiagError(FirstTemplate->getLocation(),
11036 FirstTemplate->getSourceRange(),
11037 FunctionTemplateParameterSingleDefaultArgument)
11038 << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
11039 ODRDiagNote(SecondTemplate->getLocation(),
11040 SecondTemplate->getSourceRange(),
11041 FunctionTemplateParameterSingleDefaultArgument)
11042 << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
11043 ParameterMismatch = true;
11044 break;
11045 }
11046
11047 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
11048 QualType FirstType = FirstTTPD->getDefaultArgument();
11049 QualType SecondType = SecondTTPD->getDefaultArgument();
11050 if (ComputeQualTypeODRHash(FirstType) !=
11051 ComputeQualTypeODRHash(SecondType)) {
11052 ODRDiagError(FirstTemplate->getLocation(),
11053 FirstTemplate->getSourceRange(),
11054 FunctionTemplateParameterDifferentDefaultArgument)
11055 << FirstTemplate << (i + 1) << FirstType;
11056 ODRDiagNote(SecondTemplate->getLocation(),
11057 SecondTemplate->getSourceRange(),
11058 FunctionTemplateParameterDifferentDefaultArgument)
11059 << SecondTemplate << (i + 1) << SecondType;
11060 ParameterMismatch = true;
11061 break;
11062 }
11063 }
11064
11065 if (FirstTTPD->isParameterPack() !=
11066 SecondTTPD->isParameterPack()) {
11067 ODRDiagError(FirstTemplate->getLocation(),
11068 FirstTemplate->getSourceRange(),
11069 FunctionTemplatePackParameter)
11070 << FirstTemplate << (i + 1) << FirstTTPD->isParameterPack();
11071 ODRDiagNote(SecondTemplate->getLocation(),
11072 SecondTemplate->getSourceRange(),
11073 FunctionTemplatePackParameter)
11074 << SecondTemplate << (i + 1) << SecondTTPD->isParameterPack();
11075 ParameterMismatch = true;
11076 break;
11077 }
11078 }
11079
11080 if (isa<TemplateTemplateParmDecl>(FirstParam) &&
11081 isa<TemplateTemplateParmDecl>(SecondParam)) {
11082 TemplateTemplateParmDecl *FirstTTPD =
11083 cast<TemplateTemplateParmDecl>(FirstParam);
11084 TemplateTemplateParmDecl *SecondTTPD =
11085 cast<TemplateTemplateParmDecl>(SecondParam);
11086
11087 TemplateParameterList *FirstTPL =
11088 FirstTTPD->getTemplateParameters();
11089 TemplateParameterList *SecondTPL =
11090 SecondTTPD->getTemplateParameters();
11091
11092 if (ComputeTemplateParameterListODRHash(FirstTPL) !=
11093 ComputeTemplateParameterListODRHash(SecondTPL)) {
11094 ODRDiagError(FirstTemplate->getLocation(),
11095 FirstTemplate->getSourceRange(),
11096 FunctionTemplateParameterDifferentType)
11097 << FirstTemplate << (i + 1);
11098 ODRDiagNote(SecondTemplate->getLocation(),
11099 SecondTemplate->getSourceRange(),
11100 FunctionTemplateParameterDifferentType)
11101 << SecondTemplate << (i + 1);
11102 ParameterMismatch = true;
11103 break;
11104 }
11105
11106 bool HasFirstDefaultArgument =
11107 FirstTTPD->hasDefaultArgument() &&
11108 !FirstTTPD->defaultArgumentWasInherited();
11109 bool HasSecondDefaultArgument =
11110 SecondTTPD->hasDefaultArgument() &&
11111 !SecondTTPD->defaultArgumentWasInherited();
11112 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
11113 ODRDiagError(FirstTemplate->getLocation(),
11114 FirstTemplate->getSourceRange(),
11115 FunctionTemplateParameterSingleDefaultArgument)
11116 << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
11117 ODRDiagNote(SecondTemplate->getLocation(),
11118 SecondTemplate->getSourceRange(),
11119 FunctionTemplateParameterSingleDefaultArgument)
11120 << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
11121 ParameterMismatch = true;
11122 break;
11123 }
11124
11125 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
11126 TemplateArgument FirstTA =
11127 FirstTTPD->getDefaultArgument().getArgument();
11128 TemplateArgument SecondTA =
11129 SecondTTPD->getDefaultArgument().getArgument();
11130 if (ComputeTemplateArgumentODRHash(FirstTA) !=
11131 ComputeTemplateArgumentODRHash(SecondTA)) {
11132 ODRDiagError(FirstTemplate->getLocation(),
11133 FirstTemplate->getSourceRange(),
11134 FunctionTemplateParameterDifferentDefaultArgument)
11135 << FirstTemplate << (i + 1) << FirstTA;
11136 ODRDiagNote(SecondTemplate->getLocation(),
11137 SecondTemplate->getSourceRange(),
11138 FunctionTemplateParameterDifferentDefaultArgument)
11139 << SecondTemplate << (i + 1) << SecondTA;
11140 ParameterMismatch = true;
11141 break;
11142 }
11143 }
11144
11145 if (FirstTTPD->isParameterPack() !=
11146 SecondTTPD->isParameterPack()) {
11147 ODRDiagError(FirstTemplate->getLocation(),
11148 FirstTemplate->getSourceRange(),
11149 FunctionTemplatePackParameter)
11150 << FirstTemplate << (i + 1) << FirstTTPD->isParameterPack();
11151 ODRDiagNote(SecondTemplate->getLocation(),
11152 SecondTemplate->getSourceRange(),
11153 FunctionTemplatePackParameter)
11154 << SecondTemplate << (i + 1) << SecondTTPD->isParameterPack();
11155 ParameterMismatch = true;
11156 break;
11157 }
11158 }
11159
11160 if (isa<NonTypeTemplateParmDecl>(FirstParam) &&
11161 isa<NonTypeTemplateParmDecl>(SecondParam)) {
11162 NonTypeTemplateParmDecl *FirstNTTPD =
11163 cast<NonTypeTemplateParmDecl>(FirstParam);
11164 NonTypeTemplateParmDecl *SecondNTTPD =
11165 cast<NonTypeTemplateParmDecl>(SecondParam);
11166
11167 QualType FirstType = FirstNTTPD->getType();
11168 QualType SecondType = SecondNTTPD->getType();
11169 if (ComputeQualTypeODRHash(FirstType) !=
11170 ComputeQualTypeODRHash(SecondType)) {
11171 ODRDiagError(FirstTemplate->getLocation(),
11172 FirstTemplate->getSourceRange(),
11173 FunctionTemplateParameterDifferentType)
11174 << FirstTemplate << (i + 1);
11175 ODRDiagNote(SecondTemplate->getLocation(),
11176 SecondTemplate->getSourceRange(),
11177 FunctionTemplateParameterDifferentType)
11178 << SecondTemplate << (i + 1);
11179 ParameterMismatch = true;
11180 break;
11181 }
11182
11183 bool HasFirstDefaultArgument =
11184 FirstNTTPD->hasDefaultArgument() &&
11185 !FirstNTTPD->defaultArgumentWasInherited();
11186 bool HasSecondDefaultArgument =
11187 SecondNTTPD->hasDefaultArgument() &&
11188 !SecondNTTPD->defaultArgumentWasInherited();
11189 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
11190 ODRDiagError(FirstTemplate->getLocation(),
11191 FirstTemplate->getSourceRange(),
11192 FunctionTemplateParameterSingleDefaultArgument)
11193 << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
11194 ODRDiagNote(SecondTemplate->getLocation(),
11195 SecondTemplate->getSourceRange(),
11196 FunctionTemplateParameterSingleDefaultArgument)
11197 << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
11198 ParameterMismatch = true;
11199 break;
11200 }
11201
11202 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
11203 Expr *FirstDefaultArgument = FirstNTTPD->getDefaultArgument();
11204 Expr *SecondDefaultArgument = SecondNTTPD->getDefaultArgument();
11205 if (ComputeODRHash(FirstDefaultArgument) !=
11206 ComputeODRHash(SecondDefaultArgument)) {
11207 ODRDiagError(FirstTemplate->getLocation(),
11208 FirstTemplate->getSourceRange(),
11209 FunctionTemplateParameterDifferentDefaultArgument)
11210 << FirstTemplate << (i + 1) << FirstDefaultArgument;
11211 ODRDiagNote(SecondTemplate->getLocation(),
11212 SecondTemplate->getSourceRange(),
11213 FunctionTemplateParameterDifferentDefaultArgument)
11214 << SecondTemplate << (i + 1) << SecondDefaultArgument;
11215 ParameterMismatch = true;
11216 break;
11217 }
11218 }
11219
11220 if (FirstNTTPD->isParameterPack() !=
11221 SecondNTTPD->isParameterPack()) {
11222 ODRDiagError(FirstTemplate->getLocation(),
11223 FirstTemplate->getSourceRange(),
11224 FunctionTemplatePackParameter)
11225 << FirstTemplate << (i + 1) << FirstNTTPD->isParameterPack();
11226 ODRDiagNote(SecondTemplate->getLocation(),
11227 SecondTemplate->getSourceRange(),
11228 FunctionTemplatePackParameter)
11229 << SecondTemplate << (i + 1)
11230 << SecondNTTPD->isParameterPack();
11231 ParameterMismatch = true;
11232 break;
11233 }
11234 }
11235 }
11236
11237 if (ParameterMismatch) {
11238 Diagnosed = true;
11239 break;
11240 }
11241
11242 break;
11243 }
11244 }
11245
11246 if (Diagnosed)
11247 continue;
11248
11249 Diag(FirstDecl->getLocation(),
11250 diag::err_module_odr_violation_mismatch_decl_unknown)
11251 << FirstRecord << FirstModule.empty() << FirstModule << FirstDiffType
11252 << FirstDecl->getSourceRange();
11253 Diag(SecondDecl->getLocation(),
11254 diag::note_module_odr_violation_mismatch_decl_unknown)
11255 << SecondModule << FirstDiffType << SecondDecl->getSourceRange();
11256 Diagnosed = true;
11257 }
11258
11259 if (!Diagnosed) {
11260 // All definitions are updates to the same declaration. This happens if a
11261 // module instantiates the declaration of a class template specialization
11262 // and two or more other modules instantiate its definition.
11263 //
11264 // FIXME: Indicate which modules had instantiations of this definition.
11265 // FIXME: How can this even happen?
11266 Diag(Merge.first->getLocation(),
11267 diag::err_module_odr_violation_different_instantiations)
11268 << Merge.first;
11269 }
11270 }
11271
11272 // Issue ODR failures diagnostics for functions.
11273 for (auto &Merge : FunctionOdrMergeFailures) {
11274 enum ODRFunctionDifference {
11275 ReturnType,
11276 ParameterName,
11277 ParameterType,
11278 ParameterSingleDefaultArgument,
11279 ParameterDifferentDefaultArgument,
11280 FunctionBody,
11281 };
11282
11283 FunctionDecl *FirstFunction = Merge.first;
11284 std::string FirstModule = getOwningModuleNameForDiagnostic(FirstFunction);
11285
11286 bool Diagnosed = false;
11287 for (auto &SecondFunction : Merge.second) {
11288
11289 if (FirstFunction == SecondFunction)
11290 continue;
11291
11292 std::string SecondModule =
11293 getOwningModuleNameForDiagnostic(SecondFunction);
11294
11295 auto ODRDiagError = [FirstFunction, &FirstModule,
11296 this](SourceLocation Loc, SourceRange Range,
11297 ODRFunctionDifference DiffType) {
11298 return Diag(Loc, diag::err_module_odr_violation_function)
11299 << FirstFunction << FirstModule.empty() << FirstModule << Range
11300 << DiffType;
11301 };
11302 auto ODRDiagNote = [&SecondModule, this](SourceLocation Loc,
11303 SourceRange Range,
11304 ODRFunctionDifference DiffType) {
11305 return Diag(Loc, diag::note_module_odr_violation_function)
11306 << SecondModule << Range << DiffType;
11307 };
11308
11309 if (ComputeQualTypeODRHash(FirstFunction->getReturnType()) !=
11310 ComputeQualTypeODRHash(SecondFunction->getReturnType())) {
11311 ODRDiagError(FirstFunction->getReturnTypeSourceRange().getBegin(),
11312 FirstFunction->getReturnTypeSourceRange(), ReturnType)
11313 << FirstFunction->getReturnType();
11314 ODRDiagNote(SecondFunction->getReturnTypeSourceRange().getBegin(),
11315 SecondFunction->getReturnTypeSourceRange(), ReturnType)
11316 << SecondFunction->getReturnType();
11317 Diagnosed = true;
11318 break;
11319 }
11320
11321 assert(FirstFunction->param_size() == SecondFunction->param_size() &&
11322 "Merged functions with different number of parameters");
11323
11324 auto ParamSize = FirstFunction->param_size();
11325 bool ParameterMismatch = false;
11326 for (unsigned I = 0; I < ParamSize; ++I) {
11327 auto *FirstParam = FirstFunction->getParamDecl(I);
11328 auto *SecondParam = SecondFunction->getParamDecl(I);
11329
11330 assert(getContext().hasSameType(FirstParam->getType(),
11331 SecondParam->getType()) &&
11332 "Merged function has different parameter types.");
11333
11334 if (FirstParam->getDeclName() != SecondParam->getDeclName()) {
11335 ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11336 ParameterName)
11337 << I + 1 << FirstParam->getDeclName();
11338 ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11339 ParameterName)
11340 << I + 1 << SecondParam->getDeclName();
11341 ParameterMismatch = true;
11342 break;
11343 };
11344
11345 QualType FirstParamType = FirstParam->getType();
11346 QualType SecondParamType = SecondParam->getType();
11347 if (FirstParamType != SecondParamType &&
11348 ComputeQualTypeODRHash(FirstParamType) !=
11349 ComputeQualTypeODRHash(SecondParamType)) {
11350 if (const DecayedType *ParamDecayedType =
11351 FirstParamType->getAs<DecayedType>()) {
11352 ODRDiagError(FirstParam->getLocation(),
11353 FirstParam->getSourceRange(), ParameterType)
11354 << (I + 1) << FirstParamType << true
11355 << ParamDecayedType->getOriginalType();
11356 } else {
11357 ODRDiagError(FirstParam->getLocation(),
11358 FirstParam->getSourceRange(), ParameterType)
11359 << (I + 1) << FirstParamType << false;
11360 }
11361
11362 if (const DecayedType *ParamDecayedType =
11363 SecondParamType->getAs<DecayedType>()) {
11364 ODRDiagNote(SecondParam->getLocation(),
11365 SecondParam->getSourceRange(), ParameterType)
11366 << (I + 1) << SecondParamType << true
11367 << ParamDecayedType->getOriginalType();
11368 } else {
11369 ODRDiagNote(SecondParam->getLocation(),
11370 SecondParam->getSourceRange(), ParameterType)
11371 << (I + 1) << SecondParamType << false;
11372 }
11373 ParameterMismatch = true;
11374 break;
11375 }
11376
11377 const Expr *FirstInit = FirstParam->getInit();
11378 const Expr *SecondInit = SecondParam->getInit();
11379 if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
11380 ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11381 ParameterSingleDefaultArgument)
11382 << (I + 1) << (FirstInit == nullptr)
11383 << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
11384 ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11385 ParameterSingleDefaultArgument)
11386 << (I + 1) << (SecondInit == nullptr)
11387 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
11388 ParameterMismatch = true;
11389 break;
11390 }
11391
11392 if (FirstInit && SecondInit &&
11393 ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
11394 ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11395 ParameterDifferentDefaultArgument)
11396 << (I + 1) << FirstInit->getSourceRange();
11397 ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11398 ParameterDifferentDefaultArgument)
11399 << (I + 1) << SecondInit->getSourceRange();
11400 ParameterMismatch = true;
11401 break;
11402 }
11403
11404 assert(ComputeSubDeclODRHash(FirstParam) ==
11405 ComputeSubDeclODRHash(SecondParam) &&
11406 "Undiagnosed parameter difference.");
11407 }
11408
11409 if (ParameterMismatch) {
11410 Diagnosed = true;
11411 break;
11412 }
11413
11414 // If no error has been generated before now, assume the problem is in
11415 // the body and generate a message.
11416 ODRDiagError(FirstFunction->getLocation(),
11417 FirstFunction->getSourceRange(), FunctionBody);
11418 ODRDiagNote(SecondFunction->getLocation(),
11419 SecondFunction->getSourceRange(), FunctionBody);
11420 Diagnosed = true;
11421 break;
11422 }
11423 (void)Diagnosed;
11424 assert(Diagnosed && "Unable to emit ODR diagnostic.");
11425 }
11426
11427 // Issue ODR failures diagnostics for enums.
11428 for (auto &Merge : EnumOdrMergeFailures) {
11429 enum ODREnumDifference {
11430 SingleScopedEnum,
11431 EnumTagKeywordMismatch,
11432 SingleSpecifiedType,
11433 DifferentSpecifiedTypes,
11434 DifferentNumberEnumConstants,
11435 EnumConstantName,
11436 EnumConstantSingleInitilizer,
11437 EnumConstantDifferentInitilizer,
11438 };
11439
11440 // If we've already pointed out a specific problem with this enum, don't
11441 // bother issuing a general "something's different" diagnostic.
11442 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
11443 continue;
11444
11445 EnumDecl *FirstEnum = Merge.first;
11446 std::string FirstModule = getOwningModuleNameForDiagnostic(FirstEnum);
11447
11448 using DeclHashes =
11449 llvm::SmallVector<std::pair<EnumConstantDecl *, unsigned>, 4>;
11450 auto PopulateHashes = [&ComputeSubDeclODRHash, FirstEnum](
11451 DeclHashes &Hashes, EnumDecl *Enum) {
11452 for (auto *D : Enum->decls()) {
11453 // Due to decl merging, the first EnumDecl is the parent of
11454 // Decls in both records.
11455 if (!ODRHash::isWhitelistedDecl(D, FirstEnum))
11456 continue;
11457 assert(isa<EnumConstantDecl>(D) && "Unexpected Decl kind");
11458 Hashes.emplace_back(cast<EnumConstantDecl>(D),
11459 ComputeSubDeclODRHash(D));
11460 }
11461 };
11462 DeclHashes FirstHashes;
11463 PopulateHashes(FirstHashes, FirstEnum);
11464 bool Diagnosed = false;
11465 for (auto &SecondEnum : Merge.second) {
11466
11467 if (FirstEnum == SecondEnum)
11468 continue;
11469
11470 std::string SecondModule =
11471 getOwningModuleNameForDiagnostic(SecondEnum);
11472
11473 auto ODRDiagError = [FirstEnum, &FirstModule,
11474 this](SourceLocation Loc, SourceRange Range,
11475 ODREnumDifference DiffType) {
11476 return Diag(Loc, diag::err_module_odr_violation_enum)
11477 << FirstEnum << FirstModule.empty() << FirstModule << Range
11478 << DiffType;
11479 };
11480 auto ODRDiagNote = [&SecondModule, this](SourceLocation Loc,
11481 SourceRange Range,
11482 ODREnumDifference DiffType) {
11483 return Diag(Loc, diag::note_module_odr_violation_enum)
11484 << SecondModule << Range << DiffType;
11485 };
11486
11487 if (FirstEnum->isScoped() != SecondEnum->isScoped()) {
11488 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11489 SingleScopedEnum)
11490 << FirstEnum->isScoped();
11491 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11492 SingleScopedEnum)
11493 << SecondEnum->isScoped();
11494 Diagnosed = true;
11495 continue;
11496 }
11497
11498 if (FirstEnum->isScoped() && SecondEnum->isScoped()) {
11499 if (FirstEnum->isScopedUsingClassTag() !=
11500 SecondEnum->isScopedUsingClassTag()) {
11501 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11502 EnumTagKeywordMismatch)
11503 << FirstEnum->isScopedUsingClassTag();
11504 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11505 EnumTagKeywordMismatch)
11506 << SecondEnum->isScopedUsingClassTag();
11507 Diagnosed = true;
11508 continue;
11509 }
11510 }
11511
11512 QualType FirstUnderlyingType =
11513 FirstEnum->getIntegerTypeSourceInfo()
11514 ? FirstEnum->getIntegerTypeSourceInfo()->getType()
11515 : QualType();
11516 QualType SecondUnderlyingType =
11517 SecondEnum->getIntegerTypeSourceInfo()
11518 ? SecondEnum->getIntegerTypeSourceInfo()->getType()
11519 : QualType();
11520 if (FirstUnderlyingType.isNull() != SecondUnderlyingType.isNull()) {
11521 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11522 SingleSpecifiedType)
11523 << !FirstUnderlyingType.isNull();
11524 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11525 SingleSpecifiedType)
11526 << !SecondUnderlyingType.isNull();
11527 Diagnosed = true;
11528 continue;
11529 }
11530
11531 if (!FirstUnderlyingType.isNull() && !SecondUnderlyingType.isNull()) {
11532 if (ComputeQualTypeODRHash(FirstUnderlyingType) !=
11533 ComputeQualTypeODRHash(SecondUnderlyingType)) {
11534 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11535 DifferentSpecifiedTypes)
11536 << FirstUnderlyingType;
11537 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11538 DifferentSpecifiedTypes)
11539 << SecondUnderlyingType;
11540 Diagnosed = true;
11541 continue;
11542 }
11543 }
11544
11545 DeclHashes SecondHashes;
11546 PopulateHashes(SecondHashes, SecondEnum);
11547
11548 if (FirstHashes.size() != SecondHashes.size()) {
11549 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11550 DifferentNumberEnumConstants)
11551 << (int)FirstHashes.size();
11552 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11553 DifferentNumberEnumConstants)
11554 << (int)SecondHashes.size();
11555 Diagnosed = true;
11556 continue;
11557 }
11558
11559 for (unsigned I = 0; I < FirstHashes.size(); ++I) {
11560 if (FirstHashes[I].second == SecondHashes[I].second)
11561 continue;
11562 const EnumConstantDecl *FirstEnumConstant = FirstHashes[I].first;
11563 const EnumConstantDecl *SecondEnumConstant = SecondHashes[I].first;
11564
11565 if (FirstEnumConstant->getDeclName() !=
11566 SecondEnumConstant->getDeclName()) {
11567
11568 ODRDiagError(FirstEnumConstant->getLocation(),
11569 FirstEnumConstant->getSourceRange(), EnumConstantName)
11570 << I + 1 << FirstEnumConstant;
11571 ODRDiagNote(SecondEnumConstant->getLocation(),
11572 SecondEnumConstant->getSourceRange(), EnumConstantName)
11573 << I + 1 << SecondEnumConstant;
11574 Diagnosed = true;
11575 break;
11576 }
11577
11578 const Expr *FirstInit = FirstEnumConstant->getInitExpr();
11579 const Expr *SecondInit = SecondEnumConstant->getInitExpr();
11580 if (!FirstInit && !SecondInit)
11581 continue;
11582
11583 if (!FirstInit || !SecondInit) {
11584 ODRDiagError(FirstEnumConstant->getLocation(),
11585 FirstEnumConstant->getSourceRange(),
11586 EnumConstantSingleInitilizer)
11587 << I + 1 << FirstEnumConstant << (FirstInit != nullptr);
11588 ODRDiagNote(SecondEnumConstant->getLocation(),
11589 SecondEnumConstant->getSourceRange(),
11590 EnumConstantSingleInitilizer)
11591 << I + 1 << SecondEnumConstant << (SecondInit != nullptr);
11592 Diagnosed = true;
11593 break;
11594 }
11595
11596 if (ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
11597 ODRDiagError(FirstEnumConstant->getLocation(),
11598 FirstEnumConstant->getSourceRange(),
11599 EnumConstantDifferentInitilizer)
11600 << I + 1 << FirstEnumConstant;
11601 ODRDiagNote(SecondEnumConstant->getLocation(),
11602 SecondEnumConstant->getSourceRange(),
11603 EnumConstantDifferentInitilizer)
11604 << I + 1 << SecondEnumConstant;
11605 Diagnosed = true;
11606 break;
11607 }
11608 }
11609 }
11610
11611 (void)Diagnosed;
11612 assert(Diagnosed && "Unable to emit ODR diagnostic.");
11613 }
11614}
11615
11616void ASTReader::StartedDeserializing() {
11617 if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
11618 ReadTimer->startTimer();
11619}
11620
11621void ASTReader::FinishedDeserializing() {
11622 assert(NumCurrentElementsDeserializing &&
11623 "FinishedDeserializing not paired with StartedDeserializing");
11624 if (NumCurrentElementsDeserializing == 1) {
11625 // We decrease NumCurrentElementsDeserializing only after pending actions
11626 // are finished, to avoid recursively re-calling finishPendingActions().
11627 finishPendingActions();
11628 }
11629 --NumCurrentElementsDeserializing;
11630
11631 if (NumCurrentElementsDeserializing == 0) {
11632 // Propagate exception specification and deduced type updates along
11633 // redeclaration chains.
11634 //
11635 // We do this now rather than in finishPendingActions because we want to
11636 // be able to walk the complete redeclaration chains of the updated decls.
11637 while (!PendingExceptionSpecUpdates.empty() ||
11638 !PendingDeducedTypeUpdates.empty()) {
11639 auto ESUpdates = std::move(PendingExceptionSpecUpdates);
11640 PendingExceptionSpecUpdates.clear();
11641 for (auto Update : ESUpdates) {
11642 ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
11643 auto *FPT = Update.second->getType()->castAs<FunctionProtoType>();
11644 auto ESI = FPT->getExtProtoInfo().ExceptionSpec;
11645 if (auto *Listener = getContext().getASTMutationListener())
11646 Listener->ResolvedExceptionSpec(cast<FunctionDecl>(Update.second));
11647 for (auto *Redecl : Update.second->redecls())
11648 getContext().adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
11649 }
11650
11651 auto DTUpdates = std::move(PendingDeducedTypeUpdates);
11652 PendingDeducedTypeUpdates.clear();
11653 for (auto Update : DTUpdates) {
11654 ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
11655 // FIXME: If the return type is already deduced, check that it matches.
11656 getContext().adjustDeducedFunctionResultType(Update.first,
11657 Update.second);
11658 }
11659 }
11660
11661 if (ReadTimer)
11662 ReadTimer->stopTimer();
11663
11664 diagnoseOdrViolations();
11665
11666 // We are not in recursive loading, so it's safe to pass the "interesting"
11667 // decls to the consumer.
11668 if (Consumer)
11669 PassInterestingDeclsToConsumer();
11670 }
11671}
11672
11673void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
11674 if (IdentifierInfo *II = Name.getAsIdentifierInfo()) {
11675 // Remove any fake results before adding any real ones.
11676 auto It = PendingFakeLookupResults.find(II);
11677 if (It != PendingFakeLookupResults.end()) {
11678 for (auto *ND : It->second)
11679 SemaObj->IdResolver.RemoveDecl(ND);
11680 // FIXME: this works around module+PCH performance issue.
11681 // Rather than erase the result from the map, which is O(n), just clear
11682 // the vector of NamedDecls.
11683 It->second.clear();
11684 }
11685 }
11686
11687 if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) {
11688 SemaObj->TUScope->AddDecl(D);
11689 } else if (SemaObj->TUScope) {
11690 // Adding the decl to IdResolver may have failed because it was already in
11691 // (even though it was not added in scope). If it is already in, make sure
11692 // it gets in the scope as well.
11693 if (std::find(SemaObj->IdResolver.begin(Name),
11694 SemaObj->IdResolver.end(), D) != SemaObj->IdResolver.end())
11695 SemaObj->TUScope->AddDecl(D);
11696 }
11697}
11698
11699ASTReader::ASTReader(Preprocessor &PP, InMemoryModuleCache &ModuleCache,
11700 ASTContext *Context,
11701 const PCHContainerReader &PCHContainerRdr,
11702 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
11703 StringRef isysroot, bool DisableValidation,
11704 bool AllowASTWithCompilerErrors,
11705 bool AllowConfigurationMismatch, bool ValidateSystemInputs,
11706 bool UseGlobalIndex,
11707 std::unique_ptr<llvm::Timer> ReadTimer)
11708 : Listener(DisableValidation
11709 ? cast<ASTReaderListener>(new SimpleASTReaderListener(PP))
11710 : cast<ASTReaderListener>(new PCHValidator(PP, *this))),
11711 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
11712 PCHContainerRdr(PCHContainerRdr), Diags(PP.getDiagnostics()), PP(PP),
11713 ContextObj(Context), ModuleMgr(PP.getFileManager(), ModuleCache,
11714 PCHContainerRdr, PP.getHeaderSearchInfo()),
11715 DummyIdResolver(PP), ReadTimer(std::move(ReadTimer)), isysroot(isysroot),
11716 DisableValidation(DisableValidation),
11717 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
11718 AllowConfigurationMismatch(AllowConfigurationMismatch),
11719 ValidateSystemInputs(ValidateSystemInputs),
11720 UseGlobalIndex(UseGlobalIndex), CurrSwitchCaseStmts(&SwitchCaseStmts) {
11721 SourceMgr.setExternalSLocEntrySource(this);
11722
11723 for (const auto &Ext : Extensions) {
11724 auto BlockName = Ext->getExtensionMetadata().BlockName;
11725 auto Known = ModuleFileExtensions.find(BlockName);
11726 if (Known != ModuleFileExtensions.end()) {
11727 Diags.Report(diag::warn_duplicate_module_file_extension)
11728 << BlockName;
11729 continue;
11730 }
11731
11732 ModuleFileExtensions.insert({BlockName, Ext});
11733 }
11734}
11735
11736ASTReader::~ASTReader() {
11737 if (OwnsDeserializationListener)
11738 delete DeserializationListener;
11739}
11740
11741IdentifierResolver &ASTReader::getIdResolver() {
11742 return SemaObj ? SemaObj->IdResolver : DummyIdResolver;
11743}
11744
11745unsigned ASTRecordReader::readRecord(llvm::BitstreamCursor &Cursor,
11746 unsigned AbbrevID) {
11747 Idx = 0;
11748 Record.clear();
11749 return Cursor.readRecord(AbbrevID, Record);
11750}
11751//===----------------------------------------------------------------------===//
11752//// OMPClauseReader implementation
11753////===----------------------------------------------------------------------===//
11754
11755OMPClause *OMPClauseReader::readClause() {
11756 OMPClause *C;
11757 switch (Record.readInt()) {
11758 case OMPC_if:
11759 C = new (Context) OMPIfClause();
11760 break;
11761 case OMPC_final:
11762 C = new (Context) OMPFinalClause();
11763 break;
11764 case OMPC_num_threads:
11765 C = new (Context) OMPNumThreadsClause();
11766 break;
11767 case OMPC_safelen:
11768 C = new (Context) OMPSafelenClause();
11769 break;
11770 case OMPC_simdlen:
11771 C = new (Context) OMPSimdlenClause();
11772 break;
11773 case OMPC_allocator:
11774 C = new (Context) OMPAllocatorClause();
11775 break;
11776 case OMPC_collapse:
11777 C = new (Context) OMPCollapseClause();
11778 break;
11779 case OMPC_default:
11780 C = new (Context) OMPDefaultClause();
11781 break;
11782 case OMPC_proc_bind:
11783 C = new (Context) OMPProcBindClause();
11784 break;
11785 case OMPC_schedule:
11786 C = new (Context) OMPScheduleClause();
11787 break;
11788 case OMPC_ordered:
11789 C = OMPOrderedClause::CreateEmpty(Context, Record.readInt());
11790 break;
11791 case OMPC_nowait:
11792 C = new (Context) OMPNowaitClause();
11793 break;
11794 case OMPC_untied:
11795 C = new (Context) OMPUntiedClause();
11796 break;
11797 case OMPC_mergeable:
11798 C = new (Context) OMPMergeableClause();
11799 break;
11800 case OMPC_read:
11801 C = new (Context) OMPReadClause();
11802 break;
11803 case OMPC_write:
11804 C = new (Context) OMPWriteClause();
11805 break;
11806 case OMPC_update:
11807 C = new (Context) OMPUpdateClause();
11808 break;
11809 case OMPC_capture:
11810 C = new (Context) OMPCaptureClause();
11811 break;
11812 case OMPC_seq_cst:
11813 C = new (Context) OMPSeqCstClause();
11814 break;
11815 case OMPC_threads:
11816 C = new (Context) OMPThreadsClause();
11817 break;
11818 case OMPC_simd:
11819 C = new (Context) OMPSIMDClause();
11820 break;
11821 case OMPC_nogroup:
11822 C = new (Context) OMPNogroupClause();
11823 break;
11824 case OMPC_unified_address:
11825 C = new (Context) OMPUnifiedAddressClause();
11826 break;
11827 case OMPC_unified_shared_memory:
11828 C = new (Context) OMPUnifiedSharedMemoryClause();
11829 break;
11830 case OMPC_reverse_offload:
11831 C = new (Context) OMPReverseOffloadClause();
11832 break;
11833 case OMPC_dynamic_allocators:
11834 C = new (Context) OMPDynamicAllocatorsClause();
11835 break;
11836 case OMPC_atomic_default_mem_order:
11837 C = new (Context) OMPAtomicDefaultMemOrderClause();
11838 break;
11839 case OMPC_private:
11840 C = OMPPrivateClause::CreateEmpty(Context, Record.readInt());
11841 break;
11842 case OMPC_firstprivate:
11843 C = OMPFirstprivateClause::CreateEmpty(Context, Record.readInt());
11844 break;
11845 case OMPC_lastprivate:
11846 C = OMPLastprivateClause::CreateEmpty(Context, Record.readInt());
11847 break;
11848 case OMPC_shared:
11849 C = OMPSharedClause::CreateEmpty(Context, Record.readInt());
11850 break;
11851 case OMPC_reduction:
11852 C = OMPReductionClause::CreateEmpty(Context, Record.readInt());
11853 break;
11854 case OMPC_task_reduction:
11855 C = OMPTaskReductionClause::CreateEmpty(Context, Record.readInt());
11856 break;
11857 case OMPC_in_reduction:
11858 C = OMPInReductionClause::CreateEmpty(Context, Record.readInt());
11859 break;
11860 case OMPC_linear:
11861 C = OMPLinearClause::CreateEmpty(Context, Record.readInt());
11862 break;
11863 case OMPC_aligned:
11864 C = OMPAlignedClause::CreateEmpty(Context, Record.readInt());
11865 break;
11866 case OMPC_copyin:
11867 C = OMPCopyinClause::CreateEmpty(Context, Record.readInt());
11868 break;
11869 case OMPC_copyprivate:
11870 C = OMPCopyprivateClause::CreateEmpty(Context, Record.readInt());
11871 break;
11872 case OMPC_flush:
11873 C = OMPFlushClause::CreateEmpty(Context, Record.readInt());
11874 break;
11875 case OMPC_depend: {
11876 unsigned NumVars = Record.readInt();
11877 unsigned NumLoops = Record.readInt();
11878 C = OMPDependClause::CreateEmpty(Context, NumVars, NumLoops);
11879 break;
11880 }
11881 case OMPC_device:
11882 C = new (Context) OMPDeviceClause();
11883 break;
11884 case OMPC_map: {
11885 OMPMappableExprListSizeTy Sizes;
11886 Sizes.NumVars = Record.readInt();
11887 Sizes.NumUniqueDeclarations = Record.readInt();
11888 Sizes.NumComponentLists = Record.readInt();
11889 Sizes.NumComponents = Record.readInt();
11890 C = OMPMapClause::CreateEmpty(Context, Sizes);
11891 break;
11892 }
11893 case OMPC_num_teams:
11894 C = new (Context) OMPNumTeamsClause();
11895 break;
11896 case OMPC_thread_limit:
11897 C = new (Context) OMPThreadLimitClause();
11898 break;
11899 case OMPC_priority:
11900 C = new (Context) OMPPriorityClause();
11901 break;
11902 case OMPC_grainsize:
11903 C = new (Context) OMPGrainsizeClause();
11904 break;
11905 case OMPC_num_tasks:
11906 C = new (Context) OMPNumTasksClause();
11907 break;
11908 case OMPC_hint:
11909 C = new (Context) OMPHintClause();
11910 break;
11911 case OMPC_dist_schedule:
11912 C = new (Context) OMPDistScheduleClause();
11913 break;
11914 case OMPC_defaultmap:
11915 C = new (Context) OMPDefaultmapClause();
11916 break;
11917 case OMPC_to: {
11918 OMPMappableExprListSizeTy Sizes;
11919 Sizes.NumVars = Record.readInt();
11920 Sizes.NumUniqueDeclarations = Record.readInt();
11921 Sizes.NumComponentLists = Record.readInt();
11922 Sizes.NumComponents = Record.readInt();
11923 C = OMPToClause::CreateEmpty(Context, Sizes);
11924 break;
11925 }
11926 case OMPC_from: {
11927 OMPMappableExprListSizeTy Sizes;
11928 Sizes.NumVars = Record.readInt();
11929 Sizes.NumUniqueDeclarations = Record.readInt();
11930 Sizes.NumComponentLists = Record.readInt();
11931 Sizes.NumComponents = Record.readInt();
11932 C = OMPFromClause::CreateEmpty(Context, Sizes);
11933 break;
11934 }
11935 case OMPC_use_device_ptr: {
11936 OMPMappableExprListSizeTy Sizes;
11937 Sizes.NumVars = Record.readInt();
11938 Sizes.NumUniqueDeclarations = Record.readInt();
11939 Sizes.NumComponentLists = Record.readInt();
11940 Sizes.NumComponents = Record.readInt();
11941 C = OMPUseDevicePtrClause::CreateEmpty(Context, Sizes);
11942 break;
11943 }
11944 case OMPC_is_device_ptr: {
11945 OMPMappableExprListSizeTy Sizes;
11946 Sizes.NumVars = Record.readInt();
11947 Sizes.NumUniqueDeclarations = Record.readInt();
11948 Sizes.NumComponentLists = Record.readInt();
11949 Sizes.NumComponents = Record.readInt();
11950 C = OMPIsDevicePtrClause::CreateEmpty(Context, Sizes);
11951 break;
11952 }
11953 case OMPC_allocate:
11954 C = OMPAllocateClause::CreateEmpty(Context, Record.readInt());
11955 break;
11956 }
11957 Visit(C);
11958 C->setLocStart(Record.readSourceLocation());
11959 C->setLocEnd(Record.readSourceLocation());
11960
11961 return C;
11962}
11963
11964void OMPClauseReader::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) {
11965 C->setPreInitStmt(Record.readSubStmt(),
11966 static_cast<OpenMPDirectiveKind>(Record.readInt()));
11967}
11968
11969void OMPClauseReader::VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C) {
11970 VisitOMPClauseWithPreInit(C);
11971 C->setPostUpdateExpr(Record.readSubExpr());
11972}
11973
11974void OMPClauseReader::VisitOMPIfClause(OMPIfClause *C) {
11975 VisitOMPClauseWithPreInit(C);
11976 C->setNameModifier(static_cast<OpenMPDirectiveKind>(Record.readInt()));
11977 C->setNameModifierLoc(Record.readSourceLocation());
11978 C->setColonLoc(Record.readSourceLocation());
11979 C->setCondition(Record.readSubExpr());
11980 C->setLParenLoc(Record.readSourceLocation());
11981}
11982
11983void OMPClauseReader::VisitOMPFinalClause(OMPFinalClause *C) {
11984 C->setCondition(Record.readSubExpr());
11985 C->setLParenLoc(Record.readSourceLocation());
11986}
11987
11988void OMPClauseReader::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
11989 VisitOMPClauseWithPreInit(C);
11990 C->setNumThreads(Record.readSubExpr());
11991 C->setLParenLoc(Record.readSourceLocation());
11992}
11993
11994void OMPClauseReader::VisitOMPSafelenClause(OMPSafelenClause *C) {
11995 C->setSafelen(Record.readSubExpr());
11996 C->setLParenLoc(Record.readSourceLocation());
11997}
11998
11999void OMPClauseReader::VisitOMPSimdlenClause(OMPSimdlenClause *C) {
12000 C->setSimdlen(Record.readSubExpr());
12001 C->setLParenLoc(Record.readSourceLocation());
12002}
12003
12004void OMPClauseReader::VisitOMPAllocatorClause(OMPAllocatorClause *C) {
12005 C->setAllocator(Record.readExpr());
12006 C->setLParenLoc(Record.readSourceLocation());
12007}
12008
12009void OMPClauseReader::VisitOMPCollapseClause(OMPCollapseClause *C) {
12010 C->setNumForLoops(Record.readSubExpr());
12011 C->setLParenLoc(Record.readSourceLocation());
12012}
12013
12014void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) {
12015 C->setDefaultKind(
12016 static_cast<OpenMPDefaultClauseKind>(Record.readInt()));
12017 C->setLParenLoc(Record.readSourceLocation());
12018 C->setDefaultKindKwLoc(Record.readSourceLocation());
12019}
12020
12021void OMPClauseReader::VisitOMPProcBindClause(OMPProcBindClause *C) {
12022 C->setProcBindKind(
12023 static_cast<OpenMPProcBindClauseKind>(Record.readInt()));
12024 C->setLParenLoc(Record.readSourceLocation());
12025 C->setProcBindKindKwLoc(Record.readSourceLocation());
12026}
12027
12028void OMPClauseReader::VisitOMPScheduleClause(OMPScheduleClause *C) {
12029 VisitOMPClauseWithPreInit(C);
12030 C->setScheduleKind(
12031 static_cast<OpenMPScheduleClauseKind>(Record.readInt()));
12032 C->setFirstScheduleModifier(
12033 static_cast<OpenMPScheduleClauseModifier>(Record.readInt()));
12034 C->setSecondScheduleModifier(
12035 static_cast<OpenMPScheduleClauseModifier>(Record.readInt()));
12036 C->setChunkSize(Record.readSubExpr());
12037 C->setLParenLoc(Record.readSourceLocation());
12038 C->setFirstScheduleModifierLoc(Record.readSourceLocation());
12039 C->setSecondScheduleModifierLoc(Record.readSourceLocation());
12040 C->setScheduleKindLoc(Record.readSourceLocation());
12041 C->setCommaLoc(Record.readSourceLocation());
12042}
12043
12044void OMPClauseReader::VisitOMPOrderedClause(OMPOrderedClause *C) {
12045 C->setNumForLoops(Record.readSubExpr());
12046 for (unsigned I = 0, E = C->NumberOfLoops; I < E; ++I)
12047 C->setLoopNumIterations(I, Record.readSubExpr());
12048 for (unsigned I = 0, E = C->NumberOfLoops; I < E; ++I)
12049 C->setLoopCounter(I, Record.readSubExpr());
12050 C->setLParenLoc(Record.readSourceLocation());
12051}
12052
12053void OMPClauseReader::VisitOMPNowaitClause(OMPNowaitClause *) {}
12054
12055void OMPClauseReader::VisitOMPUntiedClause(OMPUntiedClause *) {}
12056
12057void OMPClauseReader::VisitOMPMergeableClause(OMPMergeableClause *) {}
12058
12059void OMPClauseReader::VisitOMPReadClause(OMPReadClause *) {}
12060
12061void OMPClauseReader::VisitOMPWriteClause(OMPWriteClause *) {}
12062
12063void OMPClauseReader::VisitOMPUpdateClause(OMPUpdateClause *) {}
12064
12065void OMPClauseReader::VisitOMPCaptureClause(OMPCaptureClause *) {}
12066
12067void OMPClauseReader::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
12068
12069void OMPClauseReader::VisitOMPThreadsClause(OMPThreadsClause *) {}
12070
12071void OMPClauseReader::VisitOMPSIMDClause(OMPSIMDClause *) {}
12072
12073void OMPClauseReader::VisitOMPNogroupClause(OMPNogroupClause *) {}
12074
12075void OMPClauseReader::VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *) {}
12076
12077void OMPClauseReader::VisitOMPUnifiedSharedMemoryClause(
12078 OMPUnifiedSharedMemoryClause *) {}
12079
12080void OMPClauseReader::VisitOMPReverseOffloadClause(OMPReverseOffloadClause *) {}
12081
12082void
12083OMPClauseReader::VisitOMPDynamicAllocatorsClause(OMPDynamicAllocatorsClause *) {
12084}
12085
12086void OMPClauseReader::VisitOMPAtomicDefaultMemOrderClause(
12087 OMPAtomicDefaultMemOrderClause *C) {
12088 C->setAtomicDefaultMemOrderKind(
12089 static_cast<OpenMPAtomicDefaultMemOrderClauseKind>(Record.readInt()));
12090 C->setLParenLoc(Record.readSourceLocation());
12091 C->setAtomicDefaultMemOrderKindKwLoc(Record.readSourceLocation());
12092}
12093
12094void OMPClauseReader::VisitOMPPrivateClause(OMPPrivateClause *C) {
12095 C->setLParenLoc(Record.readSourceLocation());
12096 unsigned NumVars = C->varlist_size();
12097 SmallVector<Expr *, 16> Vars;
12098 Vars.reserve(NumVars);
12099 for (unsigned i = 0; i != NumVars; ++i)
12100 Vars.push_back(Record.readSubExpr());
12101 C->setVarRefs(Vars);
12102 Vars.clear();
12103 for (unsigned i = 0; i != NumVars; ++i)
12104 Vars.push_back(Record.readSubExpr());
12105 C->setPrivateCopies(Vars);
12106}
12107
12108void OMPClauseReader::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {
12109 VisitOMPClauseWithPreInit(C);
12110 C->setLParenLoc(Record.readSourceLocation());
12111 unsigned NumVars = C->varlist_size();
12112 SmallVector<Expr *, 16> Vars;
12113 Vars.reserve(NumVars);
12114 for (unsigned i = 0; i != NumVars; ++i)
12115 Vars.push_back(Record.readSubExpr());
12116 C->setVarRefs(Vars);
12117 Vars.clear();
12118 for (unsigned i = 0; i != NumVars; ++i)
12119 Vars.push_back(Record.readSubExpr());
12120 C->setPrivateCopies(Vars);
12121 Vars.clear();
12122 for (unsigned i = 0; i != NumVars; ++i)
12123 Vars.push_back(Record.readSubExpr());
12124 C->setInits(Vars);
12125}
12126
12127void OMPClauseReader::VisitOMPLastprivateClause(OMPLastprivateClause *C) {
12128 VisitOMPClauseWithPostUpdate(C);
12129 C->setLParenLoc(Record.readSourceLocation());
12130 unsigned NumVars = C->varlist_size();
12131 SmallVector<Expr *, 16> Vars;
12132 Vars.reserve(NumVars);
12133 for (unsigned i = 0; i != NumVars; ++i)
12134 Vars.push_back(Record.readSubExpr());
12135 C->setVarRefs(Vars);
12136 Vars.clear();
12137 for (unsigned i = 0; i != NumVars; ++i)
12138 Vars.push_back(Record.readSubExpr());
12139 C->setPrivateCopies(Vars);
12140 Vars.clear();
12141 for (unsigned i = 0; i != NumVars; ++i)
12142 Vars.push_back(Record.readSubExpr());
12143 C->setSourceExprs(Vars);
12144 Vars.clear();
12145 for (unsigned i = 0; i != NumVars; ++i)
12146 Vars.push_back(Record.readSubExpr());
12147 C->setDestinationExprs(Vars);
12148 Vars.clear();
12149 for (unsigned i = 0; i != NumVars; ++i)
12150 Vars.push_back(Record.readSubExpr());
12151 C->setAssignmentOps(Vars);
12152}
12153
12154void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) {
12155 C->setLParenLoc(Record.readSourceLocation());
12156 unsigned NumVars = C->varlist_size();
12157 SmallVector<Expr *, 16> Vars;
12158 Vars.reserve(NumVars);
12159 for (unsigned i = 0; i != NumVars; ++i)
12160 Vars.push_back(Record.readSubExpr());
12161 C->setVarRefs(Vars);
12162}
12163
12164void OMPClauseReader::VisitOMPReductionClause(OMPReductionClause *C) {
12165 VisitOMPClauseWithPostUpdate(C);
12166 C->setLParenLoc(Record.readSourceLocation());
12167 C->setColonLoc(Record.readSourceLocation());
12168 NestedNameSpecifierLoc NNSL = Record.readNestedNameSpecifierLoc();
12169 DeclarationNameInfo DNI;
12170 Record.readDeclarationNameInfo(DNI);
12171 C->setQualifierLoc(NNSL);
12172 C->setNameInfo(DNI);
12173
12174 unsigned NumVars = C->varlist_size();
12175 SmallVector<Expr *, 16> Vars;
12176 Vars.reserve(NumVars);
12177 for (unsigned i = 0; i != NumVars; ++i)
12178 Vars.push_back(Record.readSubExpr());
12179 C->setVarRefs(Vars);
12180 Vars.clear();
12181 for (unsigned i = 0; i != NumVars; ++i)
12182 Vars.push_back(Record.readSubExpr());
12183 C->setPrivates(Vars);
12184 Vars.clear();
12185 for (unsigned i = 0; i != NumVars; ++i)
12186 Vars.push_back(Record.readSubExpr());
12187 C->setLHSExprs(Vars);
12188 Vars.clear();
12189 for (unsigned i = 0; i != NumVars; ++i)
12190 Vars.push_back(Record.readSubExpr());
12191 C->setRHSExprs(Vars);
12192 Vars.clear();
12193 for (unsigned i = 0; i != NumVars; ++i)
12194 Vars.push_back(Record.readSubExpr());
12195 C->setReductionOps(Vars);
12196}
12197
12198void OMPClauseReader::VisitOMPTaskReductionClause(OMPTaskReductionClause *C) {
12199 VisitOMPClauseWithPostUpdate(C);
12200 C->setLParenLoc(Record.readSourceLocation());
12201 C->setColonLoc(Record.readSourceLocation());
12202 NestedNameSpecifierLoc NNSL = Record.readNestedNameSpecifierLoc();
12203 DeclarationNameInfo DNI;
12204 Record.readDeclarationNameInfo(DNI);
12205 C->setQualifierLoc(NNSL);
12206 C->setNameInfo(DNI);
12207
12208 unsigned NumVars = C->varlist_size();
12209 SmallVector<Expr *, 16> Vars;
12210 Vars.reserve(NumVars);
12211 for (unsigned I = 0; I != NumVars; ++I)
12212 Vars.push_back(Record.readSubExpr());
12213 C->setVarRefs(Vars);
12214 Vars.clear();
12215 for (unsigned I = 0; I != NumVars; ++I)
12216 Vars.push_back(Record.readSubExpr());
12217 C->setPrivates(Vars);
12218 Vars.clear();
12219 for (unsigned I = 0; I != NumVars; ++I)
12220 Vars.push_back(Record.readSubExpr());
12221 C->setLHSExprs(Vars);
12222 Vars.clear();
12223 for (unsigned I = 0; I != NumVars; ++I)
12224 Vars.push_back(Record.readSubExpr());
12225 C->setRHSExprs(Vars);
12226 Vars.clear();
12227 for (unsigned I = 0; I != NumVars; ++I)
12228 Vars.push_back(Record.readSubExpr());
12229 C->setReductionOps(Vars);
12230}
12231
12232void OMPClauseReader::VisitOMPInReductionClause(OMPInReductionClause *C) {
12233 VisitOMPClauseWithPostUpdate(C);
12234 C->setLParenLoc(Record.readSourceLocation());
12235 C->setColonLoc(Record.readSourceLocation());
12236 NestedNameSpecifierLoc NNSL = Record.readNestedNameSpecifierLoc();
12237 DeclarationNameInfo DNI;
12238 Record.readDeclarationNameInfo(DNI);
12239 C->setQualifierLoc(NNSL);
12240 C->setNameInfo(DNI);
12241
12242 unsigned NumVars = C->varlist_size();
12243 SmallVector<Expr *, 16> Vars;
12244 Vars.reserve(NumVars);
12245 for (unsigned I = 0; I != NumVars; ++I)
12246 Vars.push_back(Record.readSubExpr());
12247 C->setVarRefs(Vars);
12248 Vars.clear();
12249 for (unsigned I = 0; I != NumVars; ++I)
12250 Vars.push_back(Record.readSubExpr());
12251 C->setPrivates(Vars);
12252 Vars.clear();
12253 for (unsigned I = 0; I != NumVars; ++I)
12254 Vars.push_back(Record.readSubExpr());
12255 C->setLHSExprs(Vars);
12256 Vars.clear();
12257 for (unsigned I = 0; I != NumVars; ++I)
12258 Vars.push_back(Record.readSubExpr());
12259 C->setRHSExprs(Vars);
12260 Vars.clear();
12261 for (unsigned I = 0; I != NumVars; ++I)
12262 Vars.push_back(Record.readSubExpr());
12263 C->setReductionOps(Vars);
12264 Vars.clear();
12265 for (unsigned I = 0; I != NumVars; ++I)
12266 Vars.push_back(Record.readSubExpr());
12267 C->setTaskgroupDescriptors(Vars);
12268}
12269
12270void OMPClauseReader::VisitOMPLinearClause(OMPLinearClause *C) {
12271 VisitOMPClauseWithPostUpdate(C);
12272 C->setLParenLoc(Record.readSourceLocation());
12273 C->setColonLoc(Record.readSourceLocation());
12274 C->setModifier(static_cast<OpenMPLinearClauseKind>(Record.readInt()));
12275 C->setModifierLoc(Record.readSourceLocation());
12276 unsigned NumVars = C->varlist_size();
12277 SmallVector<Expr *, 16> Vars;
12278 Vars.reserve(NumVars);
12279 for (unsigned i = 0; i != NumVars; ++i)
12280 Vars.push_back(Record.readSubExpr());
12281 C->setVarRefs(Vars);
12282 Vars.clear();
12283 for (unsigned i = 0; i != NumVars; ++i)
12284 Vars.push_back(Record.readSubExpr());
12285 C->setPrivates(Vars);
12286 Vars.clear();
12287 for (unsigned i = 0; i != NumVars; ++i)
12288 Vars.push_back(Record.readSubExpr());
12289 C->setInits(Vars);
12290 Vars.clear();
12291 for (unsigned i = 0; i != NumVars; ++i)
12292 Vars.push_back(Record.readSubExpr());
12293 C->setUpdates(Vars);
12294 Vars.clear();
12295 for (unsigned i = 0; i != NumVars; ++i)
12296 Vars.push_back(Record.readSubExpr());
12297 C->setFinals(Vars);
12298 C->setStep(Record.readSubExpr());
12299 C->setCalcStep(Record.readSubExpr());
12300}
12301
12302void OMPClauseReader::VisitOMPAlignedClause(OMPAlignedClause *C) {
12303 C->setLParenLoc(Record.readSourceLocation());
12304 C->setColonLoc(Record.readSourceLocation());
12305 unsigned NumVars = C->varlist_size();
12306 SmallVector<Expr *, 16> Vars;
12307 Vars.reserve(NumVars);
12308 for (unsigned i = 0; i != NumVars; ++i)
12309 Vars.push_back(Record.readSubExpr());
12310 C->setVarRefs(Vars);
12311 C->setAlignment(Record.readSubExpr());
12312}
12313
12314void OMPClauseReader::VisitOMPCopyinClause(OMPCopyinClause *C) {
12315 C->setLParenLoc(Record.readSourceLocation());
12316 unsigned NumVars = C->varlist_size();
12317 SmallVector<Expr *, 16> Exprs;
12318 Exprs.reserve(NumVars);
12319 for (unsigned i = 0; i != NumVars; ++i)
12320 Exprs.push_back(Record.readSubExpr());
12321 C->setVarRefs(Exprs);
12322 Exprs.clear();
12323 for (unsigned i = 0; i != NumVars; ++i)
12324 Exprs.push_back(Record.readSubExpr());
12325 C->setSourceExprs(Exprs);
12326 Exprs.clear();
12327 for (unsigned i = 0; i != NumVars; ++i)
12328 Exprs.push_back(Record.readSubExpr());
12329 C->setDestinationExprs(Exprs);
12330 Exprs.clear();
12331 for (unsigned i = 0; i != NumVars; ++i)
12332 Exprs.push_back(Record.readSubExpr());
12333 C->setAssignmentOps(Exprs);
12334}
12335
12336void OMPClauseReader::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) {
12337 C->setLParenLoc(Record.readSourceLocation());
12338 unsigned NumVars = C->varlist_size();
12339 SmallVector<Expr *, 16> Exprs;
12340 Exprs.reserve(NumVars);
12341 for (unsigned i = 0; i != NumVars; ++i)
12342 Exprs.push_back(Record.readSubExpr());
12343 C->setVarRefs(Exprs);
12344 Exprs.clear();
12345 for (unsigned i = 0; i != NumVars; ++i)
12346 Exprs.push_back(Record.readSubExpr());
12347 C->setSourceExprs(Exprs);
12348 Exprs.clear();
12349 for (unsigned i = 0; i != NumVars; ++i)
12350 Exprs.push_back(Record.readSubExpr());
12351 C->setDestinationExprs(Exprs);
12352 Exprs.clear();
12353 for (unsigned i = 0; i != NumVars; ++i)
12354 Exprs.push_back(Record.readSubExpr());
12355 C->setAssignmentOps(Exprs);
12356}
12357
12358void OMPClauseReader::VisitOMPFlushClause(OMPFlushClause *C) {
12359 C->setLParenLoc(Record.readSourceLocation());
12360 unsigned NumVars = C->varlist_size();
12361 SmallVector<Expr *, 16> Vars;
12362 Vars.reserve(NumVars);
12363 for (unsigned i = 0; i != NumVars; ++i)
12364 Vars.push_back(Record.readSubExpr());
12365 C->setVarRefs(Vars);
12366}
12367
12368void OMPClauseReader::VisitOMPDependClause(OMPDependClause *C) {
12369 C->setLParenLoc(Record.readSourceLocation());
12370 C->setDependencyKind(
12371 static_cast<OpenMPDependClauseKind>(Record.readInt()));
12372 C->setDependencyLoc(Record.readSourceLocation());
12373 C->setColonLoc(Record.readSourceLocation());
12374 unsigned NumVars = C->varlist_size();
12375 SmallVector<Expr *, 16> Vars;
12376 Vars.reserve(NumVars);
12377 for (unsigned I = 0; I != NumVars; ++I)
12378 Vars.push_back(Record.readSubExpr());
12379 C->setVarRefs(Vars);
12380 for (unsigned I = 0, E = C->getNumLoops(); I < E; ++I)
12381 C->setLoopData(I, Record.readSubExpr());
12382}
12383
12384void OMPClauseReader::VisitOMPDeviceClause(OMPDeviceClause *C) {
12385 VisitOMPClauseWithPreInit(C);
12386 C->setDevice(Record.readSubExpr());
12387 C->setLParenLoc(Record.readSourceLocation());
12388}
12389
12390void OMPClauseReader::VisitOMPMapClause(OMPMapClause *C) {
12391 C->setLParenLoc(Record.readSourceLocation());
12392 for (unsigned I = 0; I < OMPMapClause::NumberOfModifiers; ++I) {
12393 C->setMapTypeModifier(
12394 I, static_cast<OpenMPMapModifierKind>(Record.readInt()));
12395 C->setMapTypeModifierLoc(I, Record.readSourceLocation());
12396 }
12397 C->setMapperQualifierLoc(Record.readNestedNameSpecifierLoc());
12398 DeclarationNameInfo DNI;
12399 Record.readDeclarationNameInfo(DNI);
12400 C->setMapperIdInfo(DNI);
12401 C->setMapType(
12402 static_cast<OpenMPMapClauseKind>(Record.readInt()));
12403 C->setMapLoc(Record.readSourceLocation());
12404 C->setColonLoc(Record.readSourceLocation());
12405 auto NumVars = C->varlist_size();
12406 auto UniqueDecls = C->getUniqueDeclarationsNum();
12407 auto TotalLists = C->getTotalComponentListNum();
12408 auto TotalComponents = C->getTotalComponentsNum();
12409
12410 SmallVector<Expr *, 16> Vars;
12411 Vars.reserve(NumVars);
12412 for (unsigned i = 0; i != NumVars; ++i)
12413 Vars.push_back(Record.readExpr());
12414 C->setVarRefs(Vars);
12415
12416 SmallVector<Expr *, 16> UDMappers;
12417 UDMappers.reserve(NumVars);
12418 for (unsigned I = 0; I < NumVars; ++I)
12419 UDMappers.push_back(Record.readExpr());
12420 C->setUDMapperRefs(UDMappers);
12421
12422 SmallVector<ValueDecl *, 16> Decls;
12423 Decls.reserve(UniqueDecls);
12424 for (unsigned i = 0; i < UniqueDecls; ++i)
12425 Decls.push_back(Record.readDeclAs<ValueDecl>());
12426 C->setUniqueDecls(Decls);
12427
12428 SmallVector<unsigned, 16> ListsPerDecl;
12429 ListsPerDecl.reserve(UniqueDecls);
12430 for (unsigned i = 0; i < UniqueDecls; ++i)
12431 ListsPerDecl.push_back(Record.readInt());
12432 C->setDeclNumLists(ListsPerDecl);
12433
12434 SmallVector<unsigned, 32> ListSizes;
12435 ListSizes.reserve(TotalLists);
12436 for (unsigned i = 0; i < TotalLists; ++i)
12437 ListSizes.push_back(Record.readInt());
12438 C->setComponentListSizes(ListSizes);
12439
12440 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12441 Components.reserve(TotalComponents);
12442 for (unsigned i = 0; i < TotalComponents; ++i) {
12443 Expr *AssociatedExpr = Record.readExpr();
12444 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12445 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12446 AssociatedExpr, AssociatedDecl));
12447 }
12448 C->setComponents(Components, ListSizes);
12449}
12450
12451void OMPClauseReader::VisitOMPAllocateClause(OMPAllocateClause *C) {
12452 C->setLParenLoc(Record.readSourceLocation());
12453 C->setColonLoc(Record.readSourceLocation());
12454 C->setAllocator(Record.readSubExpr());
12455 unsigned NumVars = C->varlist_size();
12456 SmallVector<Expr *, 16> Vars;
12457 Vars.reserve(NumVars);
12458 for (unsigned i = 0; i != NumVars; ++i)
12459 Vars.push_back(Record.readSubExpr());
12460 C->setVarRefs(Vars);
12461}
12462
12463void OMPClauseReader::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) {
12464 VisitOMPClauseWithPreInit(C);
12465 C->setNumTeams(Record.readSubExpr());
12466 C->setLParenLoc(Record.readSourceLocation());
12467}
12468
12469void OMPClauseReader::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) {
12470 VisitOMPClauseWithPreInit(C);
12471 C->setThreadLimit(Record.readSubExpr());
12472 C->setLParenLoc(Record.readSourceLocation());
12473}
12474
12475void OMPClauseReader::VisitOMPPriorityClause(OMPPriorityClause *C) {
12476 C->setPriority(Record.readSubExpr());
12477 C->setLParenLoc(Record.readSourceLocation());
12478}
12479
12480void OMPClauseReader::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) {
12481 C->setGrainsize(Record.readSubExpr());
12482 C->setLParenLoc(Record.readSourceLocation());
12483}
12484
12485void OMPClauseReader::VisitOMPNumTasksClause(OMPNumTasksClause *C) {
12486 C->setNumTasks(Record.readSubExpr());
12487 C->setLParenLoc(Record.readSourceLocation());
12488}
12489
12490void OMPClauseReader::VisitOMPHintClause(OMPHintClause *C) {
12491 C->setHint(Record.readSubExpr());
12492 C->setLParenLoc(Record.readSourceLocation());
12493}
12494
12495void OMPClauseReader::VisitOMPDistScheduleClause(OMPDistScheduleClause *C) {
12496 VisitOMPClauseWithPreInit(C);
12497 C->setDistScheduleKind(
12498 static_cast<OpenMPDistScheduleClauseKind>(Record.readInt()));
12499 C->setChunkSize(Record.readSubExpr());
12500 C->setLParenLoc(Record.readSourceLocation());
12501 C->setDistScheduleKindLoc(Record.readSourceLocation());
12502 C->setCommaLoc(Record.readSourceLocation());
12503}
12504
12505void OMPClauseReader::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) {
12506 C->setDefaultmapKind(
12507 static_cast<OpenMPDefaultmapClauseKind>(Record.readInt()));
12508 C->setDefaultmapModifier(
12509 static_cast<OpenMPDefaultmapClauseModifier>(Record.readInt()));
12510 C->setLParenLoc(Record.readSourceLocation());
12511 C->setDefaultmapModifierLoc(Record.readSourceLocation());
12512 C->setDefaultmapKindLoc(Record.readSourceLocation());
12513}
12514
12515void OMPClauseReader::VisitOMPToClause(OMPToClause *C) {
12516 C->setLParenLoc(Record.readSourceLocation());
12517 C->setMapperQualifierLoc(Record.readNestedNameSpecifierLoc());
12518 DeclarationNameInfo DNI;
12519 Record.readDeclarationNameInfo(DNI);
12520 C->setMapperIdInfo(DNI);
12521 auto NumVars = C->varlist_size();
12522 auto UniqueDecls = C->getUniqueDeclarationsNum();
12523 auto TotalLists = C->getTotalComponentListNum();
12524 auto TotalComponents = C->getTotalComponentsNum();
12525
12526 SmallVector<Expr *, 16> Vars;
12527 Vars.reserve(NumVars);
12528 for (unsigned i = 0; i != NumVars; ++i)
12529 Vars.push_back(Record.readSubExpr());
12530 C->setVarRefs(Vars);
12531
12532 SmallVector<Expr *, 16> UDMappers;
12533 UDMappers.reserve(NumVars);
12534 for (unsigned I = 0; I < NumVars; ++I)
12535 UDMappers.push_back(Record.readSubExpr());
12536 C->setUDMapperRefs(UDMappers);
12537
12538 SmallVector<ValueDecl *, 16> Decls;
12539 Decls.reserve(UniqueDecls);
12540 for (unsigned i = 0; i < UniqueDecls; ++i)
12541 Decls.push_back(Record.readDeclAs<ValueDecl>());
12542 C->setUniqueDecls(Decls);
12543
12544 SmallVector<unsigned, 16> ListsPerDecl;
12545 ListsPerDecl.reserve(UniqueDecls);
12546 for (unsigned i = 0; i < UniqueDecls; ++i)
12547 ListsPerDecl.push_back(Record.readInt());
12548 C->setDeclNumLists(ListsPerDecl);
12549
12550 SmallVector<unsigned, 32> ListSizes;
12551 ListSizes.reserve(TotalLists);
12552 for (unsigned i = 0; i < TotalLists; ++i)
12553 ListSizes.push_back(Record.readInt());
12554 C->setComponentListSizes(ListSizes);
12555
12556 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12557 Components.reserve(TotalComponents);
12558 for (unsigned i = 0; i < TotalComponents; ++i) {
12559 Expr *AssociatedExpr = Record.readSubExpr();
12560 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12561 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12562 AssociatedExpr, AssociatedDecl));
12563 }
12564 C->setComponents(Components, ListSizes);
12565}
12566
12567void OMPClauseReader::VisitOMPFromClause(OMPFromClause *C) {
12568 C->setLParenLoc(Record.readSourceLocation());
12569 C->setMapperQualifierLoc(Record.readNestedNameSpecifierLoc());
12570 DeclarationNameInfo DNI;
12571 Record.readDeclarationNameInfo(DNI);
12572 C->setMapperIdInfo(DNI);
12573 auto NumVars = C->varlist_size();
12574 auto UniqueDecls = C->getUniqueDeclarationsNum();
12575 auto TotalLists = C->getTotalComponentListNum();
12576 auto TotalComponents = C->getTotalComponentsNum();
12577
12578 SmallVector<Expr *, 16> Vars;
12579 Vars.reserve(NumVars);
12580 for (unsigned i = 0; i != NumVars; ++i)
12581 Vars.push_back(Record.readSubExpr());
12582 C->setVarRefs(Vars);
12583
12584 SmallVector<Expr *, 16> UDMappers;
12585 UDMappers.reserve(NumVars);
12586 for (unsigned I = 0; I < NumVars; ++I)
12587 UDMappers.push_back(Record.readSubExpr());
12588 C->setUDMapperRefs(UDMappers);
12589
12590 SmallVector<ValueDecl *, 16> Decls;
12591 Decls.reserve(UniqueDecls);
12592 for (unsigned i = 0; i < UniqueDecls; ++i)
12593 Decls.push_back(Record.readDeclAs<ValueDecl>());
12594 C->setUniqueDecls(Decls);
12595
12596 SmallVector<unsigned, 16> ListsPerDecl;
12597 ListsPerDecl.reserve(UniqueDecls);
12598 for (unsigned i = 0; i < UniqueDecls; ++i)
12599 ListsPerDecl.push_back(Record.readInt());
12600 C->setDeclNumLists(ListsPerDecl);
12601
12602 SmallVector<unsigned, 32> ListSizes;
12603 ListSizes.reserve(TotalLists);
12604 for (unsigned i = 0; i < TotalLists; ++i)
12605 ListSizes.push_back(Record.readInt());
12606 C->setComponentListSizes(ListSizes);
12607
12608 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12609 Components.reserve(TotalComponents);
12610 for (unsigned i = 0; i < TotalComponents; ++i) {
12611 Expr *AssociatedExpr = Record.readSubExpr();
12612 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12613 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12614 AssociatedExpr, AssociatedDecl));
12615 }
12616 C->setComponents(Components, ListSizes);
12617}
12618
12619void OMPClauseReader::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *C) {
12620 C->setLParenLoc(Record.readSourceLocation());
12621 auto NumVars = C->varlist_size();
12622 auto UniqueDecls = C->getUniqueDeclarationsNum();
12623 auto TotalLists = C->getTotalComponentListNum();
12624 auto TotalComponents = C->getTotalComponentsNum();
12625
12626 SmallVector<Expr *, 16> Vars;
12627 Vars.reserve(NumVars);
12628 for (unsigned i = 0; i != NumVars; ++i)
12629 Vars.push_back(Record.readSubExpr());
12630 C->setVarRefs(Vars);
12631 Vars.clear();
12632 for (unsigned i = 0; i != NumVars; ++i)
12633 Vars.push_back(Record.readSubExpr());
12634 C->setPrivateCopies(Vars);
12635 Vars.clear();
12636 for (unsigned i = 0; i != NumVars; ++i)
12637 Vars.push_back(Record.readSubExpr());
12638 C->setInits(Vars);
12639
12640 SmallVector<ValueDecl *, 16> Decls;
12641 Decls.reserve(UniqueDecls);
12642 for (unsigned i = 0; i < UniqueDecls; ++i)
12643 Decls.push_back(Record.readDeclAs<ValueDecl>());
12644 C->setUniqueDecls(Decls);
12645
12646 SmallVector<unsigned, 16> ListsPerDecl;
12647 ListsPerDecl.reserve(UniqueDecls);
12648 for (unsigned i = 0; i < UniqueDecls; ++i)
12649 ListsPerDecl.push_back(Record.readInt());
12650 C->setDeclNumLists(ListsPerDecl);
12651
12652 SmallVector<unsigned, 32> ListSizes;
12653 ListSizes.reserve(TotalLists);
12654 for (unsigned i = 0; i < TotalLists; ++i)
12655 ListSizes.push_back(Record.readInt());
12656 C->setComponentListSizes(ListSizes);
12657
12658 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12659 Components.reserve(TotalComponents);
12660 for (unsigned i = 0; i < TotalComponents; ++i) {
12661 Expr *AssociatedExpr = Record.readSubExpr();
12662 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12663 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12664 AssociatedExpr, AssociatedDecl));
12665 }
12666 C->setComponents(Components, ListSizes);
12667}
12668
12669void OMPClauseReader::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) {
12670 C->setLParenLoc(Record.readSourceLocation());
12671 auto NumVars = C->varlist_size();
12672 auto UniqueDecls = C->getUniqueDeclarationsNum();
12673 auto TotalLists = C->getTotalComponentListNum();
12674 auto TotalComponents = C->getTotalComponentsNum();
12675
12676 SmallVector<Expr *, 16> Vars;
12677 Vars.reserve(NumVars);
12678 for (unsigned i = 0; i != NumVars; ++i)
12679 Vars.push_back(Record.readSubExpr());
12680 C->setVarRefs(Vars);
12681 Vars.clear();
12682
12683 SmallVector<ValueDecl *, 16> Decls;
12684 Decls.reserve(UniqueDecls);
12685 for (unsigned i = 0; i < UniqueDecls; ++i)
12686 Decls.push_back(Record.readDeclAs<ValueDecl>());
12687 C->setUniqueDecls(Decls);
12688
12689 SmallVector<unsigned, 16> ListsPerDecl;
12690 ListsPerDecl.reserve(UniqueDecls);
12691 for (unsigned i = 0; i < UniqueDecls; ++i)
12692 ListsPerDecl.push_back(Record.readInt());
12693 C->setDeclNumLists(ListsPerDecl);
12694
12695 SmallVector<unsigned, 32> ListSizes;
12696 ListSizes.reserve(TotalLists);
12697 for (unsigned i = 0; i < TotalLists; ++i)
12698 ListSizes.push_back(Record.readInt());
12699 C->setComponentListSizes(ListSizes);
12700
12701 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12702 Components.reserve(TotalComponents);
12703 for (unsigned i = 0; i < TotalComponents; ++i) {
12704 Expr *AssociatedExpr = Record.readSubExpr();
12705 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12706 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12707 AssociatedExpr, AssociatedDecl));
12708 }
12709 C->setComponents(Components, ListSizes);
12710}
12711